﻿#ifndef LK_COLLECTION_LIST_
#define LK_COLLECTION_LIST_
/**@author 由W意波(LuoJun)编写*/
namespace LK
{
	namespace Collection
	{
		/**
		@brief 链表节点（链表元）*/
		template<class T>struct ListElement
		{
			/**
			@brief 上一个节点指针*/
			ListElement* head;
			/**
			@brief 节点元素指针*/
			T* pointer;
			/**
			@brief 下一个节点指针*/
			ListElement* next;
			/**
			@brief 构造函数*/
			template<class AnyT>ListElement(ListElement*ph, AnyT t, ListElement*pn) :head(ph), pointer(new T(t)), next(pn) {}
			ListElement(ListElement*ph, ListElement*pn) :head(ph), pointer(new T()), next(pn) {}
			ListElement() :head(NULL), pointer(NULL), next(NULL) {}
			/**
			@brief 复制构造*/
			ListElement(const ListElement& ve) : head(ve.head), pointer(new T(*ve.pointer)), next(ve.next) {}
			/**
			@breif 使用指定元素构造新的链表元*/
			template<typename AnyT>static ListElement* Make(AnyT t)
			{
				ListElement* p = new ListElement();
				p->pointer = new T(t);
				return p;
			}
			/**
			@breif 使用指定元素和前后链表元指针来构造新的链表元*/
			template<typename AnyT>static ListElement* Make(ListElement* h, AnyT t, ListElement* n)
			{
				ListElement* p = new ListElement();
				p->head = h;
				p->pointer = new T(t);
				p->next = n;
				return p;
			}
			/**
			@brief 赋值*/
			ListElement&operator=(const ListElement& ve) { if (&ve != this) { delete pointer; head = ve.head; pointer = new T(*ve.pointer); next = ve.next; }return *this; }
			inline ~ListElement() { delete pointer; }
			/**
			@brief 获取该链表元元素的引用*/
			inline T& Current() { if (!pointer)Throw<PPointerIsNullException >(); return *pointer; }
			inline T const& Current()const { if (!pointer)Throw<PPointerIsNullException >(); return *pointer; }
			/**
			@brief 获取该链表元元素的指针，并将该链表元元素指针设置为NULL*/
			inline T* PickPointer() { T* p = pointer; pointer = NULL; return p; }
		};
		/**
		@brief 链表迭代器*/
		template<class T>struct ListIterator
		{
			typedef ListElement<T> vListElement;
			vListElement*pObject;
		public:
#ifdef _XUTILITY_
			typedef std::forward_iterator_tag iterator_category;
#endif
			typedef T value_type;
			typedef size_t difference_type;
			typedef T* pointer;
			typedef T& reference;
			typedef ListIterator<T> iterator;
			typedef ListIterator<T const> const_iterator;

			/**
			@brief 从常量链表迭代器构造*/
			inline explicit ListIterator(const_iterator const&t);
			/**
			@brief 从链表元指针构造*/
			inline ListIterator(vListElement* p) : pObject(p) {}
			/**
			@brief 默认构造*/
			inline ListIterator() : pObject(NULL) {}
			/**
			@brief 获取当前元素的引用*/
			inline T& operator*() { if (!pObject)Throw<PPointerIsNullException >(); return pObject->Current(); }
			/**
			@brief 获取当前元素的引用*/
			inline T const& operator*()const { if (!pObject)Throw<PPointerIsNullException >(); return pObject->Current(); }
			/**
			@brief 重载operator->*/
			inline T *operator->() { return *this; }
			inline T const*operator->()const { return *this; }
			/**
			@brief 自动转换到指针*/
			inline operator T *() { if (!pObject)Throw<PPointerIsNullException >();  return pObject->pointer; }
			inline operator T const*()const { if (!pObject)Throw<PPointerIsNullException >();  return pObject->pointer; }
			/**
			@brief 自增*/
			inline ListIterator& operator++() { if (!pObject)Throw<PPointerIsNullException >(); pObject = pObject->next; return*this; }
			/**
			@brief 自减*/
			inline ListIterator& operator--() { if (!pObject)Throw<PPointerIsNullException >(); pObject = pObject->head; return*this; }
			/**
			@brief 自增*/
			inline ListIterator operator++(int) { vListElement*p = pObject; ++*this; return p; }
			/**
			@brief 自减*/
			inline ListIterator operator--(int) { vListElement*p = pObject; --*this; return p; }
			/**
			@brief 获取数据指针*/
			vListElement* get()const { return pObject; }
		};
		template<class T>struct ListIterator <T const >
		{
		public:
#ifdef _XUTILITY_
			typedef std::forward_iterator_tag iterator_category;
#endif
			typedef T const value_type;
			typedef size_t difference_type;
			typedef T const* pointer;
			typedef T const& reference;
			typedef ListElement<T const> vListElement;

			inline ListIterator(ListIterator<T> const& t) :pObject(t.p) {}
			inline ListIterator(vListElement const* p) : pObject(p) {}
			inline ListIterator() : pObject(NULL) {}
			inline T const& operator*()const { if (!pObject)Throw<PPointerIsNullException >(); return pObject->Current(); }
			vListElement*pObject;
			inline T const*operator->()const { return *this; }
			inline ListIterator& operator++() { if (!pObject)Throw<PPointerIsNullException >(); pObject = pObject->next; return*this; }
			inline ListIterator& operator--() { if (!pObject)Throw<PPointerIsNullException >(); pObject = pObject->head; return*this; }
			inline ListIterator operator++(int) { vListElement*p = pObject; ++*this; return p; }
			inline ListIterator operator--(int) { vListElement*p = pObject; --*this; return p; }
			friend inline bool operator==(ListIterator const& it1, ListIterator const& it2) { return it1.pObject == it2.pObject; }
			friend inline bool operator!=(ListIterator const& it1, ListIterator const& it2) { return it1.pObject != it2.pObject; }
			/**
			@brief 获取数据指针*/
			vListElement* get()const { return pObject; }
		};
		/**
		@brief 链表反向迭代器*/
		template<class T>struct ReverseListIterator
		{
			typedef ListElement<T> vListElement;
			vListElement*pObject;
		public:
#ifdef _XUTILITY_
			typedef std::forward_iterator_tag iterator_category;
#endif
			typedef T value_type;
			typedef size_t difference_type;
			typedef T* pointer;
			typedef T& reference;
			typedef ListIterator<T> iterator;
			typedef ListIterator<T const> const_iterator;

			/**
			@brief 从常量链表迭代器构造*/
			inline explicit ReverseListIterator(ReverseListIterator<T const> const&t);
			/**
			@brief 从链表元指针构造*/
			inline ReverseListIterator(vListElement* p) : pObject(p) {}
			/**
			@brief 默认构造*/
			inline ReverseListIterator() : pObject(NULL) {}
			/**
			@brief 获取当前元素的引用*/
			inline T& operator*() { if (!pObject)Throw<PPointerIsNullException >(); return pObject->Current(); }
			/**
			@brief 获取当前元素的引用*/
			inline T& operator*()const { if (!pObject)Throw<PPointerIsNullException >(); return pObject->Current(); }
			/**
			@brief 重载operator->*/
			inline T *operator->() { return *this; }
			inline T const*operator->()const { return *this; }
			/**
			@brief 自动转换到指针*/
			inline operator T *() { if (!pObject)Throw<PPointerIsNullException >();  return pObject->pointer; }
			inline operator T const*()const { if (!pObject)Throw<PPointerIsNullException >();  return pObject->pointer; }
			/**
			@brief 自减*/
			inline ReverseListIterator& operator--() { if (!pObject)Throw<PPointerIsNullException >(); pObject = pObject->next; return*this; }
			/**
			@brief 自增*/
			inline ReverseListIterator& operator++() { if (!pObject)Throw<PPointerIsNullException >(); pObject = pObject->head; return*this; }
			/**
			@brief 自减*/
			inline ReverseListIterator operator--(int) { vListElement*p = pObject; ++*this; return p; }
			/**
			@brief 自增*/
			inline ReverseListIterator operator++(int) { vListElement*p = pObject; --*this; return p; }
			/**
			@brief 获取数据指针*/
			vListElement* get()const { return pObject; }
		};
		template<class T>struct ReverseListIterator <T const >
		{
		public:
#ifdef _XUTILITY_
			typedef std::forward_iterator_tag iterator_category;
#endif
			typedef T const value_type;
			typedef size_t difference_type;
			typedef T const* pointer;
			typedef T const& reference;
			typedef ListElement<T const> vListElement;

			inline ReverseListIterator(ReverseListIterator<T> const& t) :pObject(t.p) {}
			inline ReverseListIterator(vListElement const* p) : pObject(p) {}
			inline ReverseListIterator() : pObject(NULL) {}
			inline T const& operator*() { if (!pObject)Throw<PPointerIsNullException >(); return pObject->Current(); }
			vListElement*pObject;
			inline T const*operator->()const { return *this; }
			inline ReverseListIterator& operator--() { if (!pObject)Throw<PPointerIsNullException >(); pObject = pObject->next; return*this; }
			inline ReverseListIterator& operator++() { if (!pObject)Throw<PPointerIsNullException >(); pObject = pObject->head; return*this; }
			inline ReverseListIterator operator--(int) { vListElement*p = pObject; ++*this; return p; }
			inline ReverseListIterator operator++(int) { vListElement*p = pObject; --*this; return p; }
			friend inline bool operator==(ReverseListIterator const& it1, ReverseListIterator const& it2) { return it1.pObject == it2.pObject; }
			friend inline bool operator!=(ReverseListIterator const& it1, ReverseListIterator const& it2) { return it1.pObject != it2.pObject; }
			/**
			@brief 获取数据指针*/
			vListElement* get()const { return pObject; }
		};
		template<class T>inline ListIterator<T>::ListIterator(ListIterator<T const> const&t) : pObject(const_cast<T*>(t.pObject)) {}
		template<class T>inline ReverseListIterator<T>::ReverseListIterator(ReverseListIterator<T const> const&t) : pObject(const_cast<T*>(t.pObject)) {}
		/**
		@brief 表示一个双向链表（实体）*/
		template<typename T>struct List :virtual ICloneables
		{
			typedef ListElement<T> vListElement;
			/**
			@brief 第一个链表元素*/
			vListElement* pFirst;
			/**
			@brief 最后一个链表元素*/
			vListElement* pLast;
			/**
			@brief 指示是否为循环列表*/
			bool _isRec;
			/**
			@brief 移除并返回新指针*/
			vListElement* RemoveAt(vListElement* p);
			/**
			@breif 插入t并返回新指针*/
			template<class AnyT>vListElement* InsertAt(vListElement* p, AnyT t);
			/**
			@brief 制作临时链表
			@param [模板,可选]AnyT用以指定迭代器类型
			@param [写出]参数opt用以输出结果副本的起始节点指针
			@param [传入]参数iterBegin表示被复制内容的起始迭代器
			@param [传入]参数iterEnd表示被复制内容的终止迭代器
			@param [写出,可选]参数plen用以输出结果链表的节点数
			@return 返回结果副本的模节点指针*/
			template<class AnyT>static vListElement* MakeTmpList(vListElement** opt, AnyT iterBegin, AnyT iterEnd, index_t *plen = NULL);//从迭代器创建副本
			/**
			@brief 制作临时链表
			@param [模板,可选]AnyT用以指定迭代器类型
			@param [写出]参数opt用以输出结果副本的起始节点指针
			@param [传入]参数p表示被复制内容的起始迭代器
			@param [传入]参数count表示被复制内容的元素数
			@return 返回结果副本的模节点指针*/
			template<class AnyT>static vListElement* MakeTmpList(vListElement** opt, AnyT p, index_t count);//从迭代器和数量创建副本
		public:
			/**
			@brief 移除两个链表元之间指定的元素(包含这两个指针)并返回该位置链表元指针
			@param [传入]参数pstart表示起始移除链表元指针
			@param [传入]参数plast表示最后一个要移除元素的链表元指针
			@return 返回替换起始移除位置的指针*/
			vListElement* RemoveByPointer(vListElement* pstart, vListElement* plast);
			/**
			@brief 移除指定链表元及其之后的len个元素并返回该位置链表元指针
			@param [传入]参数pstart表示起始移除链表元指针
			@param [传入]参数len表示需要移除的元素数量
			@return 返回替换起始移除位置的指针*/
			vListElement* RemoveByPointer(vListElement* pstart, index_t len);
			/**
			@breif 在指定的链表元位置插入由pStart和plast指定的临时链表
			@param [传入]参数p表示插入的链表元位置
			@param [传入]参数pStart表示指定链表的头节点
			@param [传入]参数pLast表示指定链表的末节点
			@param [传入]参数count表示指定链表的节点数
			@return 返回替换原来位置的新链表元指针
			@note ps和pe所代表临时链表必须是非循环链表，而且交由该对象管理，不可再在外部delete
			@note count一定要跟pStart与pLast对应，比如pStart跟pLast指向同一个节点时，count为1*/
			vListElement* InsertByPointer(vListElement* p, vListElement* pstart, vListElement* plast, index_t count);
			/**
			@breif 在指定的链表元位置插入由迭代器指定的内容的副本
			@param [模板,可选]AnyT指定迭代器类型
			@param [传入]参数p表示插入的链表元位置
			@param [传入]参数iterBegin表示指定内容的起始迭代器
			@param [传入]参数iterEnd表示插入内容的终止迭代器
			@return 返回替换原来位置的新链表元指针
			@note 如果插入的是循环迭代器，则只取1环*/
			template<class AnyT>inline vListElement* InsertByPointer(vListElement* p, AnyT iterBegin, AnyT iterEnd);
			/**
			@breif 在指定的链表元位置插入由迭代器指定的内容的副本
			@param [模板,可选]AnyT指定迭代器类型
			@param [传入]参数p表示插入的链表元位置
			@param [传入]参数iterBegin表示指定内容的起始迭代器
			@param [传入]参数count表示插入内容的元素数
			@return 返回替换原来位置的新链表元指针
			@note 如果插入的是循环迭代器，则根据count来循环取值*/
			template<class AnyT>inline vListElement* InsertByPointer(vListElement* p, AnyT iterBegin, index_t count);
#ifdef _INITIALIZER_LIST_//初始化列表支持
			List(std::initializer_list<T> const& lst) :_isRec(false), Length(0), pFirst(NULL), pLast(NULL) { for (std::initializer_list<T>::iterator i = lst.begin(); i != lst.end(); ++i)Append(*i); }
#endif
			BMETHODS(PList<T>, List)
			/**
			@brief 产生浅表副本*/
			List* Clone()const { return new List(*this); }
			/**
			@brief检查下标是否越界*/
			inline bool CheckIndex(index_t startIndex)const;
			inline bool CheckIndex(index_t startIndex, index_t len)const;
			//获取元素数
			virtual index_t size()const { return Length; }
			//清理
			virtual void clear() { Resize(0); }
			/**
			@brief 获取一个bool值，指示该列表是否循环*/
			bool GetIsRecycle()const { return _isRec; }
			/**
			@brief 设置一个bool值，指示该列表是否循环*/
			void SetIsRecycle(bool is) { _isRec = is; if (Length != 0) { pLast->next = is ? pFirst : NULL; pFirst->head = is ? pLast : NULL; } }
			/**
			@brief 链表元素数量*/
			index_t Length;
			/**
			@brief 通过索引获取获取链表元指针*/
			vListElement* GetVListElementPointerByIndex(index_t index);
			/**
			@brief 与另一个链表交换元素*/
			void SwapWith(List& x);
			/**
			@brief 析构函数*/
			virtual ~List();
			/**
			@brief 默认构造*/
			List();
			/**
			@brief 构造n个默认构造元素的List*/
			List(index_t n);
			/**
			@brief 复制构造函数*/
			List(const List&);
#ifdef SUPPORT_RIGHT_VALUE_REFERENCE
			/**
			@brief 右值构造函数*/
			List(const List&&);
#endif
			/**
			@brief 构造并使用一个值初始化所有元素
			@param [模板,可选]参数AnyT表示val的原始数据类型
			@param [传入]参数len表示元素个数
			@param [传入]参数val表示初始值
			@param [传入,可选]参数isRecycle指示该链表是否是循环链表，默认是false*/
			template<class AnyT>List(index_t len, AnyT const& val, bool isRecycle = false);
			/**
			@brief 从迭代器构造
			@param [模板,可选]参数VT表示迭代器的容器数据类型
			@param [模板,可选]参数AnyT表示迭代器检索元素类型
			@param [传入]参数begin表示起始迭代器
			@param [传入]参数end表示终止迭代器
			@note 当该迭代器为循环迭代器时，生成的链表将是循环的*/
			template<class IT>List(IT const&begin, IT const&end,typename UseIf<IsConvertible<typename IT::value_type,T>::V>::T*p=NULL);
			/**
			@brief 赋值*/
			List& operator=(const List&);
#ifdef SUPPORT_RIGHT_VALUE_REFERENCE
			List& operator=(const List&&);
#endif
			/**
			@brief 提供使用下标进行的随机访问（不推荐此类访问方式）*/
			T& operator[](index_t index);
			/**
			@brief 随机访问*/
			inline T const& operator[](index_t index)const { return (*const_cast<List<T>*>(this))[index]; }
			/**
			@brief 获取第一个元素的迭代器*/
			inline ListIterator<T> begin();
			/**
			@brief 获取第一个元素的迭代器*/
			inline ListIterator<T const> begin()const { return const_cast<List*>(this)->begin(); }
			/**
			@brief 获取最后一个元素的迭代器*/
			inline ReverseListIterator<T> rbegin();
			/**
			@brief 获取最后一个元素的迭代器*/
			inline ReverseListIterator<T const> rbegin()const { return const_cast<List*>(this)->rbegin(); }
			/**
			@brief 获取最后终止位置元素的迭代器*/
			inline ListIterator<T> end();
			/**
			@brief 获取最后终止位置元素的迭代器*/
			inline ListIterator<T const> end()const;
			/**
			@brief 获取起始前位置元素的迭代器*/
			inline ReverseListIterator<T> rend();
			/**
			@brief 获取起始前位置元素的迭代器*/
			inline ReverseListIterator<T const> rend()const;

			/**
			@brief 获取第一个元素的引用*/
			T& FirstElement();
			/**
			@brief 获取第一个元素的引用*/
			T const&FirstElement()const;
			/**
			@brief 获取最后一个元素的引用*/
			T& LastElement();
			/**
			@brief 获取最后一个元素的引用*/
			T const&LastElement()const;

			/**
			@brief 在该链表的指定区域查找元素与指定值相等的第一个节点所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex表示区域起始位置，默认是0
			@param [传入]参数equalMethod提供比较链表节点元素和t相等的方法
			@return 返回匹配节点的位置，如果没有节点的元素与指定值相等，则返回-1*/
			template<class AnyT, class EqualFunctionType> index_t IndexOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod)const;
			/**
			@brief 在该链表的指定区域查找元素与指定值相等的第一个节点所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的节点数
			@param [传入]参数equalMethod提供比较节点元素和t相等的方法
			@return 返回匹配节点的位置，如果没有节点元素与指定值相等，则返回-1*/
			template<class AnyT, class EqualFunctionType> index_t IndexOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod)const;
			/**
			@brief 在该链表的指定区域查找元素与指定值相等的最后一个节点所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex表示区域起始位置，默认是0
			@param [传入]参数equalMethod提供比较节点元素和t相等的方法
			@return 返回匹配节点的位置，如果没有节点元素与指定值相等，则返回-1*/
			template<class AnyT, class EqualFunctionType> index_t LastIndexOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod)const;
			/**
			@brief 在该链表的指定区域查找元素与指定值相等的最后一个节点所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的元素数
			@param [传入]参数equalMethod提供比较链表节点元素和t相等的方法
			@return 返回匹配节点的位置，如果没有节点元素与指定值相等，则返回-1*/
			template<class AnyT, class EqualFunctionType> index_t LastIndexOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod)const;

			/**
			@brief 反转链表所有元素*/
			void Reverse();

			/**
			@brief 在链表的结尾附加元素
			@param [模板,可选]参数AnyT表示t的数据类型
			@param [传入]参数t表示附加的元素
			@note 该操作将使节点数+1*/
			template<class AnyT> void Append(AnyT const & t);
			/**
			@brief 在链表的结尾位置附加数组
			@param [模板,可选]参数AnyT表示xArray的元素数据类型
			@param [传入]参数xArray表示附加的数组
			@note 该操作将使元素数+xArray数组元素数*/
			template<class AnyT>void AppendArray(IArray<AnyT> const & t);
			/**
			@brief 在链表的结尾位置附加链表
			@param [模板,可选]参数AnyT表示t的元素数据类型
			@param [传入]参数t表示附加的链表
			@note 该操作将使元素数+t链表元素数*/
			template<class AnyT>void AppendList(List<AnyT> const & t);
#ifdef SUPPORT_RIGHT_VALUE_REFERENCE
			/**
			@brief 在链表的结尾位置附加链表
			@param [模板,可选]参数AnyT表示t的元素数据类型
			@param [传入]参数t表示附加的链表
			@note 该操作将使元素数+t链表元素数*/
			void AppendList(List && t);
#endif

			/**
			@brief 在链表的指定位置插入元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数index表示插入位置
			@param [传入]参数t表示要插入的元素*/
			template<class AnyT> void Insert(index_t index, AnyT const & t);
			/**
			@brief 在链表的指定位置插入元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数iter表示插入位置（正向迭代器）
			@param [传入]参数t表示要插入的元素
			@return 返回新插入元素的迭代器*/
			template<class AnyT> ListIterator< T> Insert(const ListIterator< T>&iter, AnyT const & t);
			/**
			@brief 在链表的指定位置插入数组
			@param [模板,可选]参数AnyT表示xArray的元素数据类型
			@param [传入]参数index表示插入位置
			@param [传入]参数xArray表示要插入的数组*/
			template<class AnyT> void InsertArray(index_t index, IArray<AnyT> const &xArray);
			/**
			@brief 在链表的指定位置插入数组
			@param [模板,可选]参数AnyT表示xArray的元素数据类型
			@param [传入]参数iter表示插入位置（正向迭代器）
			@param [传入]参数xArray表示要插入的数组
			@return 返回插入数组元素第一个元素的迭代器*/
			template<class AnyT> ListIterator<T> InsertArray(const ListIterator<T>&iter, IArray<AnyT> const &xArray);
			/**
			@brief 在该链表的指定位置插入链表
			@param [模板,可选]参数AnyT表示xArray的元素数据类型
			@param [传入]参数index表示插入位置
			@param [传入]参数t表示要插入的链表*/
			template<class AnyT>void InsertList(index_t index, List<AnyT> const & t);
			/**
			@brief 在链表的指定位置插入链表
			@param [模板,可选]参数AnyT表示list的元素数据类型
			@param [传入]参数iter表示插入位置（迭代器）
			@param [传入]参数t表示要插入的链表
			@return 返回插入链表位置的新迭代器*/
			template<class AnyT>ListIterator<T> InsertList(const ListIterator<T>&iter, List<AnyT> const & list);
#ifdef SUPPORT_RIGHT_VALUE_REFERENCE
			/**
			@brief 在该链表的指定位置插入链表
			@param [模板,可选]参数AnyT表示xArray的元素数据类型
			@param [传入]参数index表示插入位置
			@param [传入]参数t表示要插入的链表*/
			void InsertList(index_t index, List && t);
			/**
			@brief 在链表的指定位置插入链表
			@param [模板,可选]参数AnyT表示list的元素数据类型
			@param [传入]参数iter表示插入位置（迭代器）
			@param [传入]参数t表示要插入的链表
			@return 返回插入链表位置的新迭代器*/
			ListIterator<T> InsertList(const ListIterator<T>&iter, List && t);
#endif

			/**
			@brief 将链表中所有元素的值设置为t
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示设置目标值*/
			template<class AnyT> void ResetTo(AnyT const & t);
			/**
			@brief 将链表中指定区域的元素的值设置为t
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示设置目标值
			@param [传入]参数startIndex表示设置起始位置
			@param [传入]参数length表示设置元素数量*/
			template<class AnyT> void ResetTo(AnyT const & t, index_t index, index_t length);

			/**
			@brief 移除指定位置的元素
			@param [传入]参数startIndex表示指定的位置
			@note 该操作将使Length-1*/
			void Remove(index_t startIndex);
			/**
			@brief 移除指定区域的元素
			@param [传入]参数startIndex表示指定的起始移除位置
			@param [传入]参数length表示需要移除的元素数量
			@note 被移除部分元素将立即被析构*/
			void Remove(index_t startIndex, index_t length);
			/**
			@brief 移除指定区域的元素
			@param [传入]参数startIter表示指定的起始移除位置
			@param [传入]参数endIter表示终结位置
			@return 返回替换起始位置元素的新迭代器*/
			ListIterator<T> Remove(const ListIterator<T>& startIter, const ListIterator<T>& endIter);

			/**
			@brief 移除指定位置的元素
			@param [传入]参数index表示指定的位置*/
			void RemoveAt(index_t index);
			/**
			@brief 移除指定位置的元素
			@param [传入]参数iter表示指定的位置
			@return 返回替换移除位置元素的新迭代器*/
			ListIterator<T> RemoveAt(const ListIterator<T>& iter);

			/**
			@brief 移除链表指定区域中首个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置，默认是0
			@param [传入]参数equalMethod提供比较链表元素和t相等的方法
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t RemoveFirstOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod);
			/**
			@brief 移除链表指定区域中首个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数length指示比较的元素数
			@param [传入]参数equalMethod提供比较链表元素和t相等的方法
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t RemoveFirstOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod);
			/**
			@brief 移除链表指定区域中首个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIter指示开始进行比较的位置
			@param [传入]参数endIter指示比较的终结位置
			@param [传入]参数equalMethod提供比较链表元素和t相等的方法
			@return 返回替换移除的元素所在位置的迭代器。如果未移除任何元素，则返回end()*/
			template<class AnyT, class EqualFunctionType>ListIterator<T> RemoveFirstOf(AnyT t, ListIterator<T>const& startIter, ListIterator<T>const& endIter, EqualFunctionType equalMethod);
			/**
			@brief 移除链表指定区域中最后一个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置，默认是0
			@param [传入]参数equalMethod提供比较链表元素和t相等的方法
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t RemoveLastOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod);
			/**
			@brief 移除链表指定区域中最后一个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数length指示比较的元素数
			@param [传入]参数equalMethod提供比较链表元素和t相等的方法
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t RemoveLastOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod);
			/**
			@brief 移除链表指定区域中最后一个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIter指示开始进行比较的位置
			@param [传入]参数endIter指示比较的终结位置
			@param [传入]参数equalMethod提供比较链表元素和t相等的方法
			@return 返回替换移除的元素所在位置的迭代器。如果未移除任何元素，则返回end()*/
			template<class AnyT, class EqualFunctionType>ListIterator<T> RemoveLastOf(AnyT t, ListIterator<T>const& startIter, ListIterator<T>const& endIter, EqualFunctionType equalMethod);
			/**
			@brief 移除指定区域内所有与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入,可选]参数startIndex表示区域的起始位置
			@param [传入]参数equalMethod提供比较t和链表元素相等的方法
			@return 返回实际移除的元素数*/
			template<class AnyT, class EqualFunctionType>index_t RemoveAllOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod);
			/**
			@brief 移除指定区域内所有与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex表示区域的起始位置
			@param [传入]参数length表示区域的元素数
			@param [传入]参数equalMethod提供比较t和链表元素相等的方法
			@return 返回实际移除的元素数*/
			template<class AnyT, class EqualFunctionType>index_t RemoveAllOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod);
			/**
			@brief 移除指定区域内所有与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIter表示区域的起始位置
			@param [传入]参数endIter表示区域的终结位置
			@param [传入]参数equalMethod提供比较t和链表元素相等的方法
			@return 返回实际移除的元素数*/
			template<class AnyT, class EqualFunctionType>index_t RemoveAllOf(AnyT t, ListIterator< T>const& startIter, ListIterator<T>const& endIter, EqualFunctionType equalMethod);
			/**
			@brief 移除指定区域内的一些与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定的值
			@param [传入]参数startIndex表示区域的起始位置
			@param [传入]参数length表示区域内的元素数
			@param [传入]参数maxCount表示最多移除的元素数
			@param [传入]参数equalMethod提供比较t和元素相等的方法
			@return 返回实际移除的元素数*/
			template<class AnyT, class EqualFunctionType>index_t RemoveSomeOf(AnyT t, index_t startIndex, index_t length, index_t maxCount, EqualFunctionType equalMethod);
			/**
			@brief 移除指定区域内的一些与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定的值
			@param [传入]参数startIter表示区域的起始位置
			@param [传入]参数endIter表示区域终结位置
			@param [传入]参数maxCount表示最多移除的元素数
			@param [传入]参数equalMethod提供比较t和元素相等的方法
			@return 返回实际移除的元素数*/
			template<class AnyT, class EqualFunctionType>index_t RemoveSomeOf(AnyT t, ListIterator<T>const& startIter, ListIterator<T>const& endIter, index_t maxCount, EqualFunctionType equalMethod);
			/**
			@brief 将指定位置的元素替换为一个指定的值
			@param [模板,可选]To表示参数to的原始数据类型
			@param [传入]参数index表示指定的位置
			@param [传入]参数to表示指定的替换后的值
			@note 与直接赋值方法不同，该方法使用重构方法来实现值替换*/
			template<class To>void RemoveAndReplaceAt(index_t index, To to);
			/**
			@brief 将指定位置的元素替换为一个指定的值
			@param [模板,可选]To表示参数to的原始数据类型
			@param [传入]参数iter表示指定的位置（正向迭代器）
			@param [传入]参数to表示指定的替换后的值
			@note 与直接赋值方法不同，该方法使用重构方法来实现值替换*/
			template<class To>void RemoveAndReplaceAt(const ListIterator<T>&iter, To to);
			/**
			@brief 将指定区域内第一个与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIndex表示指定区域的起始位置
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回移除元素所在位置，若未移除任何元素返回-1*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceFirstOf(AnyT t, To to, index_t startIndex, EqualFunctionType equalMethod);
			/**
			@brief 将指定区域内第一个与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIndex表示指定区域的起始位置
			@param [传入]参数length表示指定区域的元素数
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回移除元素所在位置，若未移除任何元素返回-1*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceFirstOf(AnyT t, To to, index_t startIndex, index_t length, EqualFunctionType equalMethod);
			/**
			@brief 将指定区域内第一个与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIter表示指定区域的起始位置（正向迭代器）
			@param [传入]参数endIter表示指定区域的终结位置（反向迭代器）
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回替换移除元素位置的新迭代器，若未移除任何元素返回end()*/
			template<class AnyT, class EqualFunctionType, class To>ListIterator<T> ReplaceFirstOf(AnyT t, To to, ListIterator<T>const& startIter, ListIterator<T>const& endIter, EqualFunctionType equalMethod);
			/**
			@brief 将指定区域内最后一个与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIndex表示指定区域的起始位置
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回移除元素所在位置，若未移除任何元素返回-1*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceLastOf(AnyT t, To to, index_t startIndex, EqualFunctionType equalMethod);
			/**
			@brief 将指定区域内最后一个与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIndex表示指定区域的起始位置
			@param [传入]参数length表示指定区域的元素数
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回移除元素所在位置，若未移除任何元素返回-1*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceLastOf(AnyT t, To to, index_t startIndex, index_t length, EqualFunctionType equalMethod);
			/**
			@brief 将指定区域内最后一个与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIter表示指定区域的起始位置（正向迭代器）
			@param [传入]参数endIter表示指定区域的终结位置（反向迭代器）
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回替换移除元素位置的新迭代器，若未移除任何元素返回end()*/
			template<class AnyT, class EqualFunctionType, class To>ListIterator<T> ReplaceLastOf(AnyT t, To to, ListIterator<T>const& startIter, ListIterator<T>const& endIter, EqualFunctionType equalMethod);
			/**
			@brief 将指定区域内所有与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIndex表示指定区域的起始位置
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回实际移除元素数量*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceAllOf(AnyT t, To to, index_t startIndex, EqualFunctionType equalMethod);
			/**
			@brief 将指定区域内所有与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIndex表示指定区域的起始位置
			@param [传入]参数length表示指定区域的元素数
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回实际移除元素数量*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceAllOf(AnyT t, To to, index_t startIndex, index_t length, EqualFunctionType equalMethod);
			/**
			@brief 将指定区域内所有与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIter表示指定区域的起始位置（正向迭代器）
			@param [传入]参数endIter表示指定区域的终结位置（反向迭代器）
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回实际移除元素数量*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceAllOf(AnyT t, To to, ListIterator<T>const& startIter, ListIterator<T>const& endIter, EqualFunctionType equalMethod);
			/**
			@brief 将指定区域内一部分与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIndex表示指定区域的起始位置
			@param [传入]参数length表示指定区域的元素数
			@param [传入]参数maxCount表示最多移除的元素数
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回实际移除元素数量*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceSomeOf(AnyT t, To to, index_t startIndex, index_t length, index_t maxCount, EqualFunctionType equalMethod);
			/**
			@brief 将指定区域内一部分与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIter表示指定区域的起始位置（正向迭代器）
			@param [传入]参数endIter表示指定区域的终结位置（反向迭代器）
			@param [传入]参数maxCount表示最多移除的元素数
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回实际移除元素数量*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceSomeOf(AnyT t, To to, ListIterator<T>const& startIter, ListIterator<T>const& endIter, index_t maxCount, EqualFunctionType equalMethod);

			/**
			@brief 统计与指定值相等的元素数量
			@param [模板,可选]AnyT表示参数t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定的值
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回与指定值相等的元素数量*/
			template<class AnyT, class EqualFunctionType>index_t CountOf(AnyT t, EqualFunctionType equalMethod);
			/**
			@brief 统计指定区域中与指定值相等的元素数量
			@param [模板,可选]AnyT表示参数t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定的值
			@param [传入]参数startIndex表示指定区域的起始位置
			@param [传入]参数length表示指定区域的元素数
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回与指定值相等的元素数量*/
			template<class AnyT, class EqualFunctionType>index_t CountOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod);
			/**
			@brief 统计指定区域中与指定值相等的元素数量
			@param [模板,可选]AnyT表示参数t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定的值
			@param [传入]参数startIter表示指定区域的起始位置（正向迭代器）
			@param [传入]参数endIter表示指定区域的终结位置（反向迭代器）
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回与指定值相等的元素数量*/
			template<class AnyT, class EqualFunctionType>index_t CountOf(AnyT t, ListIterator< T>const& startIter, ListIterator<T>const& endIter, EqualFunctionType equalMethod);

			/**
			@brief 将一个对象从集合中取出(取出后集合中将其移除)，并返回其指针
			@param [传入]参数index表示指定的位置
			@return 返回取出对象的指针
			@note 指针不再使用时请自行delete*/
			T* PickOutPointer(index_t index);

			/**
			@brief 调整大小
			@param [传入]参数len表示目标大小
			@note 当len比Length大时，新增的元素将使用默认构造；当len比Length小时，链表末尾的Length-len个元素将会被析构*/
			void Resize(index_t len);
		};

		template<class T>ListElement<T>* List<T>::RemoveAt(vListElement* p)
		{
			if (p == NULL)return NULL;
			vListElement*pn = p->next;
			vListElement*ph = p->head;
			if (ph)ph->next = pn;
			if (pn)pn->head = ph;
			if (pFirst == p)
			{
				if (pLast == p)
					pFirst = pLast = pn = NULL;
				else
					pFirst = pn;
			}
			else if (pLast == p)
				pLast = ph;
			delete p;
			const_cast<index_t&>(Length)--;
			return pn;
		}
		template<class T>template<class AnyT>ListElement<T>* List<T>::InsertAt(ListElement<T>* p, AnyT t)
		{
			if (p == NULL)//在末尾添加
			{
				p = vListElement::template Make< AnyT >(pLast, t, _isRec ? pFirst : NULL);
				if (pLast)pLast->next = p;
				pLast = p;
				if (pFirst == NULL)
				{
					pFirst = p;
					if (_isRec)p->next = p;
				}
				if (_isRec)
					pFirst->head = p;
			}
			else
			{
				vListElement* ph = p->head;
				vListElement* pn = p;
				p = vListElement::template Make<AnyT>(ph, t, pn);
				if (ph)ph->next = p;
				if (pn)pn->head = p;
				if (pn == pFirst)pFirst = p;
			}
			++const_cast<index_t&>(Length);
			return p;
		}
		template<class T>template<class AnyT> ListElement<T>* List<T>::MakeTmpList(ListElement<T>** opt, AnyT iterStart, AnyT iterEnd, index_t *plen)
		{
			if (iterStart == iterEnd) { opt = NULL; if (plen)*plen = 0; return NULL; }
			typename RemoveAllExtents<AnyT>::T iter = iterStart;
			vListElement* p;
			*opt = p = vListElement::template Make<AnyT::reference>(NULL, *iter, NULL);
			index_t len = 1;
			for (;;)
			{
				++iter;
				if (iter == iterEnd || iter == iterStart)break;
				vListElement*ph = p;
				p = vListElement::template Make<AnyT::reference>(p, *iter, NULL);
				if (ph)ph->next = p;
				if (plen)++len;
			}
			if (plen)*plen = len;
			return p;
		}
		template<class T>template<class AnyT>ListElement<T>* List<T>::MakeTmpList(ListElement<T>** opt, AnyT iter, index_t count)
		{
			if (count == 0) { opt = NULL; return NULL; }
			vListElement* p;
			*opt = p = vListElement::template Make<AnyT::reference>(NULL, *iter, NULL);
			index_t len = 1;
			while (len != count)
			{
				++iter;
				vListElement*ph = p;
				p = vListElement::template Make<AnyT::reference>(p, *iter, NULL);
				if (ph)ph->next = p;
				++len;
			}
			return p;
		}
		template<class T>ListElement<T>* List<T>::InsertByPointer(ListElement<T>* p, ListElement<T>* pb, ListElement<T>* pe, index_t len)
		{
			if (!pe || len == 0)return p;
			if (p == NULL)//在结尾插入
			{
				if (Length == 0)
				{
					pFirst = pb;
					pLast = pe;
					if (_isRec) { pb->head = pe; pe->next = pb; }
				}
				else {
					pb->head = pLast;
					if (_isRec) { pe->next = pFirst; pFirst->head = pe; }
					pLast->next = pb;
					pLast = pe;
				}
			}
			else
			{
				vListElement* ph = p->head;
				pb->head = ph;
				pe->next = p;
				if (ph)ph->next = pb;
				p->head = pe;
				if (pFirst == p)pFirst = pb;
			}
			const_cast<index_t&>(Length) += len;
			return pb;
		}
		template<class T>template<class AnyT>ListElement<T>* List<T>::InsertByPointer(ListElement<T>* p, AnyT iterBegin, AnyT iterEnd)
		{
			vListElement* pb;
			index_t len;
			vListElement* pe = MakeTmpList<AnyT>(&pb, iterBegin, iterEnd, &len);
			return InsertByPointer(p, pb, pe, len);
		}
		template<class T>template<class AnyT>ListElement<T>* List<T>::InsertByPointer(ListElement<T>* p, AnyT iterBegin, index_t count)
		{
			vListElement* pb;
			vListElement* pe = MakeTmpList<AnyT>(&pb, iterBegin, count);
			return InsertByPointer(p, pb, pe, count);
		}
		template<class T>ListElement<T>* List<T>::RemoveByPointer(vListElement* p1, vListElement* p2)
		{
			if (p1 == p2)return RemoveAt(p1);
			index_t len = Length;//记录当前元素数
			vListElement* ph = p1->head;
			vListElement* pn = p2->next;
			vListElement* p = p1;
			if (_isRec) {//循环链表有可能出现p2在p1前的情况
				for (;;)
				{
					vListElement* pp = p->next;
					if (p == pFirst) { if (p == pn)pn = NULL; pFirst = pn; }
					if (p == pLast) { if (p == ph)ph = NULL; pLast = ph; }
					delete p;
					--len;
					if (p == p2)break;
					p = pp;
				}
				if (pn)pn->head = ph;
				if (ph)ph->next = pn;
			}
			else//非循环链表不允许出现p2在p1前的情况
			{
				for (;;)
				{
					vListElement* pp = p->next;
					delete p;
					--len;
					if (p == p2)break;
					if ((p = pp) == NULL)Throw<PPointerIsNullException >();
				}
				if (pFirst == p1)pFirst = pn;
				if (pLast == p2)pLast = ph;
				if (ph)ph->next = pn;
				if (pn)pn->head = ph;
			}
			const_cast<index_t&>(Length) = len;
			return pn;
		}
		template<class T>ListElement<T>* List<T>::RemoveByPointer(vListElement* p, index_t length)
		{
			if (length == 0)return p;
			if (length == 1)return RemoveAt(p);
			index_t len = length;//记录移除元素数
			vListElement* ph = p->head;
			vListElement* pp;
			vListElement* p1 = p;
			if (_isRec) {//循环链表有可能出现p2在p1前的情况
				for (;;)
				{
					pp = p->next;
					if (p == pFirst) { if (pp == p1)pFirst = NULL; else pFirst = pp; }
					if (p == pLast) { if (p == ph)ph = NULL; pLast = ph; }
					delete p;
					if (--len == 0)break;
					p = pp;
				}
				if (pp)pp->head = ph;
				if (ph)ph->next = pp;
			}
			else//非循环链表不允许出现p2在p1前的情况
			{
				for (;;)
				{
					pp = p->next;
					delete p;
					if (--len == 0)break;
					if ((p = pp) == NULL)Throw<PPointerIsNullException >();
				}
				if (pFirst == p1)pFirst = pp;
				if (pLast == p)pLast = ph;
				if (ph)ph->next = pp;
				if (pp)pp->head = ph;
			}
			const_cast<index_t&>(Length) -= length;
			return pp;
		}
		template<class T>inline bool List<T>::CheckIndex(index_t startIndex)const
		{
			if (startIndex < 0)Throw<PInvalidArgumentException>();
			if (startIndex > Length)Throw<PIndexOutOfRangeException>();
			return startIndex == Length;
		}
		template<class T>inline bool List<T>::CheckIndex(index_t startIndex, index_t len)const
		{
			if (startIndex < 0 || len < 0)Throw<PInvalidArgumentException>();
			if (startIndex + len > Length)Throw<PIndexOutOfRangeException>();
			return startIndex == Length || len == 0;
		}
		template<class T>ListElement<T>* List<T>::GetVListElementPointerByIndex(index_t index)
		{

			if (CheckIndex(index))return NULL;
			vListElement* p;
			if (index < (Length / 2))
			{
				p = pFirst;
				while (index-- != 0)p = p->next;
			}
			else
			{
				p = pLast;
				index = Length - index;
				while (--index != 0)p = p->head;
			}
			return (vListElement*)p;
		}
		template<class T>void List<T>::SwapWith(List<T>& x)
		{
			Swap(const_cast<index_t&>(Length), const_cast<index_t&>(x.Length));
			Swap(pFirst, x.pFirst);
			Swap(pLast, x.pLast);
			Swap(_isRec, x._isRec);
		}
		template<class T>List<T>::~List()
		{
			while (pFirst != pLast)
			{
				pFirst = pFirst->next;
				delete pFirst->head;
			}
			delete pLast;
		}
		template<class T>List<T>::List() :Length(0), pFirst(NULL), pLast(NULL), _isRec(false) {}
		template<class T>List<T>::List(index_t n) : pFirst(NULL), pLast(NULL), _isRec(false), Length(0)
		{
			if (n < 0)Throw<PInvalidArgumentException>();
			if (n > 0)
			{
				vListElement* p = pFirst = new vListElement(NULL, NULL);
				for (index_t i = 1; i < n; ++i)
				{
					p->next = new vListElement(p, NULL);
					p = p->next;
				}
				pLast = p;
				const_cast<index_t&>(Length) = n;
			}
		}
		template<class T>List<T>::List(const List& v) :pFirst(NULL), pLast(NULL), _isRec(((List&)v)._isRec), Length(0)
		{
			if (v.Length > 0)
			{
				const_cast<index_t&>(Length) = v.Length;
				vListElement* pt = ((const List&)v).pFirst;
				vListElement* p = pFirst = vListElement::template Make<T&>(NULL, *pt->pointer, NULL);
				for (index_t i = 1; i < Length; ++i)
				{
					pt = pt->next;
					p->next = vListElement::template Make<T&>(p, *pt->pointer, NULL);
					p = p->next;
				}
				pLast = p;
				if (_isRec)
				{
					pFirst->head = pLast;
					pLast->next = pFirst;
				}
			}
		}
#ifdef SUPPORT_RIGHT_VALUE_REFERENCE
		template<class T>List<T>::List(const List&&v) :pFirst(v.pFirst), pLast(v.pLast), Length(v.Length), _isRec(v._isRec)
		{
			const_cast<vListElement*&>(v.pFirst) = NULL;
			const_cast<vListElement*&>(v.pLast) = NULL;
			const_cast<index_t&>(v.Length) = NULL;
		}
#endif
		template<class T>template<class AnyT>List<T>::List(index_t len, AnyT const& v, bool isRecycle)
			:Length(len), pFirst(NULL), pLast(NULL), _isRec(isRecycle)
		{
			if (len)
			{
				vListElement* p = pFirst = vListElement::template Make<AnyT const&>(NULL, v, NULL);
				while (--len > 0)
				{
					p->next = vListElement::template Make<AnyT const&>(NULL, v, NULL);
					p = p->next;
				}
				pLast = p;
				if (isRecycle) { pFirst->head = pLast; pLast->next = pFirst; }
			}
		}
		template<class T>template<class IT>List<T>::List(IT const&begin, IT const&end,typename UseIf<IsConvertible<typename IT::value_type,T>::V>::T*)
			:Length(0), pFirst(NULL), pLast(NULL), _isRec(false)
		{
			InsertByPointer<IT const&>(NULL, begin, end);
		}

		template<class T>List<T>& List<T>::operator=(const List& t)
		{
			if (&t == this)return *this;
			if (Length != 0)RemoveByPointer(pFirst, pLast);
			InsertByPointer(NULL, t.begin(), t.Length);
			return *this;
		}
#ifdef SUPPORT_RIGHT_VALUE_REFERENCE
		template<class T>List<T>& List<T>::operator=(const List&&v)
		{
			SwapWith((List&)v);
			return *this;
		}
#endif
		template<class T>T& List<T>::operator[](index_t index)
		{
			vListElement* p = GetVListElementPointerByIndex(index);
			if (p)return p->Current();
			return RThrow<T&,PIndexOutOfRangeException>();
		}
		template<class T>ListIterator<T> List<T>::begin()
		{
			return pFirst;
		}
		template<class T>ReverseListIterator<T> List<T>::rbegin()
		{
			return pLast;
		}
		template<class T>ListIterator< T> List<T>::end()
		{
			return (vListElement*)NULL;
		}
		template<class T>ReverseListIterator<T> List<T>::rend()
		{
			return (vListElement*)NULL;
		}
		template<class T>T& List<T>::FirstElement()
		{
			if (pFirst == NULL)Throw<PPointerIsNullException >();
			return *pFirst->pointer;
		}
		template<class T>T const&List<T>::FirstElement()const
		{
			return const_cast<List<T>*>(this)->FirstElement();
		}
		template<class T>T& List<T>::LastElement()
		{
			if (pLast == NULL)Throw<PPointerIsNullException >();
			return *pLast->pointer;
		}
		template<class T>T const&List<T>::LastElement()const
		{
			return const_cast<List<T>*>(this)->LastElement();
		}
		template<class T>template<class AnyT, class EqualFunctionType> index_t List<T>::IndexOf(AnyT t, index_t startIndex, EqualFunctionType equal)const
		{
			if (CheckIndex(startIndex))return -1;
			vListElement* p = GetVListElementPointerByIndex(startIndex);
			while (startIndex < Length && !equal(*p->pointer, t)) { startIndex++; p = p->next; }
			return startIndex != Length ? startIndex : -1;
		}
		template<class T>template<class AnyT, class EqualFunctionType> index_t List<T>::IndexOf(AnyT t, index_t startIndex, index_t len, EqualFunctionType equa)const
		{
			if (CheckIndex(startIndex, len))return -1;
			vListElement* p = GetVListElementPointerByIndex(startIndex);
			while (startIndex < Length && --len >= 0 && !equal(*p->pointer, t)) { startIndex++; p = p->next; }
			return len != 0 ? startIndex : -1;
		}
		template<class T>template<class AnyT, class EqualFunctionType> index_t List<T>::LastIndexOf(AnyT t, index_t startIndex, EqualFunctionType equa)const
		{
			if (CheckIndex(startIndex))return -1;
			index_t i = Length - 1;
			vListElement* p = pLast;
			while (i >= startIndex && !equal(*p->pointer, t)) { i--; p = p->head; }
			return i >= startIndex ? i : -1;
		}
		template<class T>template<class AnyT, class EqualFunctionType> index_t List<T>::LastIndexOf(AnyT t, index_t startIndex, index_t len, EqualFunctionType equa)const
		{
			if (CheckIndex(startIndex, len))return -1;
			index_t i = startIndex + len - 1;
			vListElement* p = GetVListElementPointerByIndex(i);
			while (i >= startIndex && !equal(*p->pointer, t)) { i--; p = p->head; }
			return i >= startIndex ? i : -1;
		}
		template<class T>void List<T>::Reverse()
		{
			if (pFirst)
			{
				vListElement* pb = pFirst;
				vListElement* pe = pLast;
				if ((Length & 1) != 0) {
					while (pb != pe)
					{
						Swap(pb->pointer, pe->pointer);
						pb = pb->next;
						pe = pe->head;
					}
				}
				else {
					for (;;)
					{
						Swap(pb->pointer, pe->pointer);
						pb = pb->next;
						if (pb == pe)break;
						pe = pe->head;
					}
				}
			}
		}
		template<class T>template<class AnyT> void List<T>::Append(AnyT const & t)
		{
			InsertAt<AnyT const&>(NULL, t);
		}
		template<class T>template<class AnyT> void List<T>::AppendArray(IArray<AnyT> const & t)
		{
			InsertByPointer<AnyT*>(NULL, (AnyT*)t, t.Length);
		}
		template<class T>template<class AnyT> void List<T>::AppendList(List<AnyT> const & t)
		{
			InsertByPointer(NULL, t.begin(), t.Length);
		}
#ifdef SUPPORT_RIGHT_VALUE_REFERENCE
		template<class T>void List<T>::AppendList(List && t)
		{
			if (t.Length == 0)return;
			if (Length == 0) { *this = t; return; }
			pLast->next = t.pFirst;
			t.pFirst->head = pLast;
			pLast = t.pLast;
			if (_isRec) { pFirst->head = pLast; pLast->next = pFirst; }
			else { pFirst->head = NULL; pLast->next = NULL; }
			const_cast<index_t&>(t.Length) = 0;
			const_cast<vListElement*&>(t.pFirst) = NULL;
			const_cast<vListElement*&>(t.pLast) = NULL;
		}
#endif
		template<class T>template<class AnyT> void List<T>::Insert(index_t index, AnyT const & t)
		{
			if (CheckIndex(index)) return Append(t);
			InsertAt<AnyT const &>(GetVListElementPointerByIndex(index), t);
		}
		template<class T>template<class AnyT> ListIterator<T> List<T>::Insert(const ListIterator<T>&iter, AnyT const & t)
		{
			if (iter == end()) { Append(t); return  ListIterator<T>(pLast); }
			vListElement* p = (vListElement*)iter.get();
			return InsertAt<AnyT const &>(p, t);
		}
		template<class T>template<class AnyT> void List<T>::InsertArray(index_t index, IArray<AnyT> const & t)
		{
			if (CheckIndex(index))return AppendArray(t);
			vListElement* p = GetVListElementPointerByIndex(index);
			InsertByPointer<AnyT*>(p, (AnyT*)t, t.Length);
		}
		template<class T>template<class AnyT> ListIterator<T> List<T>::InsertArray(const ListIterator<T>&iter, IArray<AnyT> const & t)
		{
			if (iter == end())return AppendArray(t);
			vListElement* p = iter.get();
			return InsertByPointer<AnyT*>(p, (AnyT*)t, t.Length);
		}
		template<class T>template<class AnyT>void List<T>::InsertList(index_t index, List<AnyT> const & t)
		{
			if (t.Length == 0)return;
			if (CheckIndex(index))return AppendList(t);
			vListElement* p = GetVListElementPointerByIndex(index);
			vListElement* pl;
			vListElement* ps = MakeTmpList<AnyT>(&pl, t.begin(), t.Length);
			InsertByPointer(p, ps, pl, t.Length);
		}
		template<class T>template<class AnyT>ListIterator<T> List<T>::InsertList(const ListIterator<T>&iter, List<AnyT> const & t)
		{
			if (iter == end())return AppendList(t);
			return InsertByPointer<ListIterator<T> >(iter.get(), t.begin(), t.end());
		}
#ifdef SUPPORT_RIGHT_VALUE_REFERENCE
		template<class T>void List<T>::InsertList(index_t index, List && t)
		{
			if (t.Length == 0)return;
			if (CheckIndex(index))return AppendList(t);
			vListElement* p = GetVListElementPointerByIndex(index);
			if (t._isRec)t.pFirst->head = t.pLast->next = NULL;
			InsertByPointer(p, t.pFirst, t.pLast, t.Length);
			t.pFirst = NULL;
			t.pLast = NULL;
			const_cast<index_t&>(t.Length) = 0;
		}
		template<class T>ListIterator<T> List<T>::InsertList(const ListIterator<T>&iter, List && t)
		{
			if (t.Length == 0)return;
			if (iter == end())return AppendList(t);
			vListElement* p = (vListElement*)iter.get();
			if (t._isRec)t.pFirst->head = t.pLast->next = NULL;
			p = InsertByPointer(p, t.pFirst, t.pLast, t.Length);
			t.pFirst = NULL;
			t.pLast = NULL;
			const_cast<index_t&>(t.Length) = 0;
			return p;
		}
#endif
		template<class T>template<class AnyT> void List<T>::ResetTo(AnyT const & t)
		{
			vListElement* p = pFirst;
			for (index_t i = 0; i < Length; ++i)
			{
				*p->pointer = t;
				p = p->next;
			}
		}
		template<class T>template<class AnyT> void List<T>::ResetTo(AnyT const & t, index_t index, index_t len)
		{
			if (CheckIndex(index, len))return;
			vListElement* p = GetVListElementPointerByIndex(index);
			for (index_t i = 0; i < len; ++i)
			{
				*p->pointer = t;
				p = p->next;
			}
		}
		template<class T>void List<T>::Remove(index_t startIndex)
		{
			if (CheckIndex(startIndex))return;
			RemoveByPointer(GetVListElementPointerByIndex(startIndex), pLast);
		}
		template<class T>void List<T>::Remove(index_t startIndex, index_t len)
		{
			if (CheckIndex(startIndex, len))return end();
			RemoveByPointer(GetVListElementPointerByIndex(startIndex), len);
		}
		template<class T>ListIterator<T> List<T>::Remove(const ListIterator<T>& startIter, const ListIterator<T>& endIter)
		{
			if (startIter == endIter || Length == 0)return startIter;
			return RemoveByPointer(startIter.get(), endIter == end() ? pLast : endIter.get()->head);
		}
		template<class T>void List<T>::RemoveAt(index_t index)
		{
			RemoveAt(GetVListElementPointerByIndex(index));
		}
		template<class T>ListIterator<T> List<T>::RemoveAt(const ListIterator<T>&iter)
		{
			return RemoveAt(iter.get());
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t List<T>::RemoveFirstOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod)
		{
			if (CheckIndex(startIndex))return -1;
			vListElement* p = GetVListElementPointerByIndex(startIndex);
			while (p != pLast && !equalMethod(p->Current(), t)) { p = p->next; ++startIndex; }
			if (p == pLast&&!equalMethod(p->Current(), t))return -1;
			RemoveAt(p);
			return startIndex;
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t List<T>::RemoveFirstOf(AnyT t, index_t startIndex, index_t len, EqualFunctionType equalMethod)
		{
			if (CheckIndex(startIndex, len))return -1;
			vListElement* p = GetVListElementPointerByIndex(startIndex);
			while (p != pLast && --len > 0 && !equalMethod(p->Current(), t)) { p = p->next; ++startIndex; }
			if ((len == 0 || p == pLast) && !equalMethod(p->Current(), t))return -1;
			RemoveAt(p);
			return startIndex;
		}
		template<class T>template<class AnyT, class EqualFunctionType>ListIterator<T> List<T>::RemoveFirstOf(AnyT t, const ListIterator<T>&startIter, const ListIterator<T>&endIter, EqualFunctionType equalMethod)
		{
			if (startIter == endIter)return end();
			ListIterator<T>p = startIter;
			while (p != endIter && !equalMethod(*p, t)) { if (++p == startIter)return end(); }
			if (p == endIter)return end();
			return RemoveAt(p);
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t List<T>::RemoveLastOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod)
		{
			if (CheckIndex(startIndex))return -1;
			index_t len = Length - startIndex;
			vListElement* p = pLast;
			while (p != pFirst && --len > 0 && !equalMethod(p->Current(), t))p = p->head;
			if ((p == pFirst || len == 0) && !equalMethod(p->Current(), t))return -1;
			RemoveAt(p);
			return startIndex + len;
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t List<T>::RemoveLastOf(AnyT t, index_t startIndex, index_t len, EqualFunctionType equalMethod)
		{
			if (CheckIndex(startIndex, len))return -1;
			vListElement* p = GetVListElementPointerByIndex(startIndex + len - 1);
			while (p != pFirst && --len > 0 && !equalMethod(p->Current(), t))p = p->head;
			if ((p == pFirst || len == 0) && !equalMethod(p->Current(), t))return -1;
			RemoveAt(p);
			return startIndex + len;
		}
		template<class T>template<class AnyT, class EqualFunctionType>ListIterator<T> List<T>::RemoveLastOf(AnyT t, const ListIterator<T>&startIter, const ListIterator<T>&endIter, EqualFunctionType equalMethod)
		{
			if (startIter == endIter)return end();
			ListIterator<T>p;
			if (endIter == end())
				p = pLast;
			else p = endIter.get()->head;
			while (p != startIter && !equalMethod(*p, t))--p;
			if (p == startIter&&!equalMethod(*p, t))return end();
			return RemoveAt(p);
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t List<T>::RemoveAllOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod)
		{
			if (CheckIndex(startIndex))return 0;
			index_t c = 0;
			vListElement* dp = NULL;
			index_t dlen = 0;
			vListElement* p = GetVListElementPointerByIndex(startIndex);
			index_t i = startIndex;
			while (i < Length)
			{
				vListElement* pp = p->next;
				if (equalMethod(p->Current(), t))
				{
					++c;
					++dlen;//移除数量递增
					if (!dp)dp = p;//移除起始位置记录
				}
				else
				{
					if (dp)//有内容需要移除
					{
						RemoveByPointer(dp, dlen);
						i -= dlen;
						dlen = 0;
						dp = NULL;
					}
					++i;
				}
				p = pp;
			}
			if (dp)RemoveByPointer(dp, dlen);
			return c;
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t List<T>::RemoveAllOf(AnyT  t, index_t startIndex, index_t len, EqualFunctionType equalMethod)
		{
			if (CheckIndex(startIndex, len))return 0;
			index_t c = 0;
			vListElement* dp = NULL;
			index_t dlen = 0;
			vListElement* p = GetVListElementPointerByIndex(startIndex);
			index_t i = 0;
			while (i < len)
			{
				vListElement* pp = p->next;
				if (equalMethod(p->Current(), t))
				{
					++c;
					++dlen;//移除数量递增
					if (!dp)dp = p;//移除起始位置记录
				}
				else
				{
					if (dp)//有内容需要移除
					{
						RemoveByPointer(dp, dlen);
						dlen = 0;
						dp = NULL;
					}
				}
				++i;
				p = pp;
			}
			if (dp)RemoveByPointer(dp, dlen);
			return c;
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t List<T>::RemoveAllOf(AnyT t, ListIterator<T>const &startIter, ListIterator<T>const &endIter, EqualFunctionType equalMethod)
		{
			if (startIter == endIter)return 0;
			index_t c = 0;
			vListElement* dp = NULL;
			index_t dlen = 0;
			vListElement* p = startIter.get();
			index_t i = 0;
			while (p != endIter.get())
			{
				vListElement* pp = p->next;
				if (equalMethod(p->Current(), t))
				{
					++c;
					++dlen;//移除数量递增
					if (!dp)dp = p;//移除起始位置记录
				}
				else
				{
					if (dp)//有内容需要移除
					{
						RemoveByPointer(dp, dlen);
						dlen = 0;
						dp = NULL;
					}
				}
				++i;
				p = pp;
				if (p == startIter.get())break;
			}
			if (dp)RemoveByPointer(dp, dlen);
			return c;
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t List<T>::RemoveSomeOf(AnyT t, index_t startIndex, index_t len, index_t maxCount, EqualFunctionType equalMethod)
		{
			if (CheckIndex(startIndex, len) || maxCount == 0)return 0;
			index_t c = 0;
			vListElement* dp = NULL;
			index_t dlen = 0;
			vListElement* p = GetVListElementPointerByIndex(startIndex);
			index_t i = 0;
			while (i < len)
			{
				vListElement* pp = p->next;
				if (equalMethod(p->Current(), t))
				{
					++c;
					++dlen;//移除数量递增
					if (!dp)dp = p;//移除起始位置记录
					if (c == maxCount)break;
				}
				else
				{
					if (dp)//有内容需要移除
					{
						RemoveByPointer(dp, dlen);
						dlen = 0;
						dp = NULL;
					}
				}
				++i;
				p = pp;
			}
			if (dp)RemoveByPointer(dp, dlen);
			return c;
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t List<T>::RemoveSomeOf(AnyT t, ListIterator<T>const& startIter, ListIterator<T>const& endIter, index_t maxCount, EqualFunctionType equalMethod)
		{
			if (startIter == endIter || maxCount == 0)return 0;
			index_t c = 0;
			vListElement* dp = NULL;
			index_t dlen = 0;
			vListElement* p = startIter.get();
			index_t i = 0;
			while (p != endIter.get())
			{
				vListElement* pp = p->next;
				if (equalMethod(p->Current(), t))
				{
					++c;
					++dlen;//移除数量递增
					if (!dp)dp = p;//移除起始位置记录
					if (c == maxCount)break;
				}
				else
				{
					if (dp)//有内容需要移除
					{
						RemoveByPointer(dp, dlen);
						dlen = 0;
						dp = NULL;
					}
				}
				++i;
				p = pp;
				if (p == startIter.get())break;
			}
			if (dp)RemoveByPointer(dp, dlen);
			return c;
		}
		template<class T>template<class To>void List<T>::RemoveAndReplaceAt(index_t index, To to)
		{
			if (CheckIndex(index))return;
			vListElement* p = GetVListElementPointerByIndex(index);
			p->pointer->T::~T();
			placementnew<T, To>(p->pointer, to);
		}
		template<class T>template<class To>void List<T>::RemoveAndReplaceAt(ListIterator<T> const&iter, To to)
		{
			vListElement* p = iter.get();
			p->pointer->T::~T();
			placementnew<T, To>(p->pointer, to);
		}
		template<class T>template<class AnyT, class EqualFunctionType, class To>index_t List<T>::ReplaceFirstOf(AnyT t, To to, index_t startIndex, EqualFunctionType equalMethod)
		{
			if (CheckIndex(startIndex))return -1;
			vListElement* p = GetVListElementPointerByIndex(startIndex);
			while (startIndex != Length)
			{
				if (equalMethod(p->Current(), t)) { *p->pointer = to; break; }
				p = p->next;
				startIndex++;
			}
			if (startIndex == Length)return -1;
			return startIndex;
		}
		template<class T>template<class AnyT, class EqualFunctionType, class To>index_t List<T>::ReplaceFirstOf(AnyT t, To to, index_t startIndex, index_t length, EqualFunctionType equalMethod)
		{
			if (CheckIndex(startIndex, length))return -1;
			vListElement* p = GetVListElementPointerByIndex(startIndex);
			index_t i = 0;
			while (i != length)
			{
				if (equalMethod(p->Current(), t)) { *p->pointer = to; break; }
				p = p->next;
				i++;
			}
			if (i == length)return -1;
			return startIndex + i;
		}
		template<class T>template<class AnyT, class EqualFunctionType, class To>ListIterator<T> List<T>::ReplaceFirstOf(AnyT t, To to, ListIterator<T>const& startIter, ListIterator<T>const& endIter, EqualFunctionType equalMethod)
		{
			if (startIter == endIter)return end();
			vListElement* p = startIter.get();
			index_t i = 0;
			while (p != endIter.get())
			{
				if (equalMethod(p->Current(), t)) { *p->pointer = to; return p; }
				p = p->next;
				if (p == startIter.get())break;
			}
			return end();
		}
		template<class T>template<class AnyT, class EqualFunctionType, class To>index_t List<T>::ReplaceLastOf(AnyT t, To to, index_t startIndex, EqualFunctionType equalMethod)
		{
			if (CheckIndex(startIndex))return -1;
			vListElement* p = pLast;
			index_t i = Length;
			while (startIndex != i)
			{
				--i;
				if (equalMethod(p->Current(), t)) { *p->pointer = to; return i; }
				p = p->head;
			}
			return -1;
		}
		template<class T>template<class AnyT, class EqualFunctionType, class To>index_t List<T>::ReplaceLastOf(AnyT t, To to, index_t startIndex, index_t length, EqualFunctionType equalMethod)
		{
			if (CheckIndex(startIndex, length))return -1;
			vListElement* p = GetVListElementPointerByIndex(startIndex + length - 1);
			index_t i = startIndex + length;
			while (startIndex != i)
			{
				--i;
				if (equalMethod(p->Current(), t)) { *p->pointer = to; return i; }
				p = p->head;
			}
			return -1;
		}
		template<class T>template<class AnyT, class EqualFunctionType, class To>ListIterator<T> List<T>::ReplaceLastOf(AnyT t, To to, ListIterator<T>const& startIter, ListIterator<T>const& endIter, EqualFunctionType equalMethod)
		{
			if (startIter == endIter)return end();
			vListElement* p = endIter == end() ? pLast : endIter.get()->head;
			while (p != startIter.get())
			{
				if (equalMethod(p->Current(), t)) { *p->pointer = to; return p; }
				p = p->head;
			}
			if (equalMethod(p->Current(), t)) { *p->pointer = to; return p; }
			return end();
		}
		template<class T>template<class AnyT, class EqualFunctionType, class To>index_t List<T>::ReplaceAllOf(AnyT t, To to, index_t startIndex, EqualFunctionType equalMethod)
		{
			if (CheckIndex(startIndex))return 0;
			vListElement* p = GetVListElementPointerByIndex(startIndex);
			index_t c = 0;
			while (startIndex != Length)
			{
				if (equalMethod(p->Current(), t)) { *p->pointer = to; ++c; }
				p = p->next;
				startIndex++;
			}
			return c;
		}
		template<class T>template<class AnyT, class EqualFunctionType, class To>index_t List<T>::ReplaceAllOf(AnyT t, To to, index_t startIndex, index_t length, EqualFunctionType equalMethod)
		{
			if (CheckIndex(startIndex, length))return 0;
			vListElement* p = GetVListElementPointerByIndex(startIndex);
			index_t i = 0;
			index_t c = 0;
			while (i != length)
			{
				if (equalMethod(p->Current(), t)) { *p->pointer = to; ++c; }
				p = p->next;
				i++;
			}
			return c;
		}
		template<class T>template<class AnyT, class EqualFunctionType, class To>index_t List<T>::ReplaceAllOf(AnyT t, To to, ListIterator<T>const& startIter, ListIterator<T>const& endIter, EqualFunctionType equalMethod)
		{
			if (startIter == endIter)return 0;
			vListElement* p = startIter.get();
			index_t c = 0;
			while (p != endIter.get())
			{
				if (equalMethod(p->Current(), t)) { *p->pointer = to; c++; }
				p = p->next;
				if (p == startIter.get())break;
			}
			return c;
		}
		template<class T>template<class AnyT, class EqualFunctionType, class To>index_t List<T>::ReplaceSomeOf(AnyT t, To to, index_t startIndex, index_t length, index_t maxCount, EqualFunctionType equalMethod)
		{
			if (CheckIndex(startIndex, length))return 0;
			if (maxCount == 0)return 0;
			vListElement* p = GetVListElementPointerByIndex(startIndex);
			index_t c = 0;
			while (length != 0)
			{
				if (equalMethod(p->Current(), t)) { *p->pointer = to; if (++c == maxCount)break; }
				p = p->next;
				length--;
			}
			return c;
		}
		template<class T>template<class AnyT, class EqualFunctionType, class To>index_t List<T>::ReplaceSomeOf(AnyT t, To to, ListIterator<T>const& startIter, ListIterator<T>const& endIter, index_t maxCount, EqualFunctionType equalMethod)
		{
			if (startIter == endIter || maxCount == 0)return 0;
			vListElement* p = startIter.get();
			index_t c = 0;
			while (p != endIter.get())
			{
				if (equalMethod(p->Current(), t)) { *p->pointer = to; if (++c == maxCount)break; }
				p = p->next;
				if (p == startIter.get())break;
			}
			return c;
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t List<T>::CountOf(AnyT t, EqualFunctionType equalMethod)
		{
			if (Length == 0)return 0;
			vListElement* p = pFirst;
			index_t c = 0;
			vListElement* pl;
			do
			{
				pl = p;
				if (equalMethod(p->Current(), t)) { ++c; }
				p = p->next;
			} while (pl != pLast);
			return c;
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t List<T>::CountOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod)
		{
			if (CheckIndex(startIndex, length))return 0;
			vListElement* p = GetVListElementPointerByIndex(startIndex);
			index_t i = 0;
			index_t c = 0;
			while (i != length)
			{
				if (equalMethod(p->Current(), t)) { ++c; }
				p = p->next;
				i++;
			}
			return c;
		}
		template<class T>template<class AnyT, class EqualFunctionType>index_t List<T>::CountOf(AnyT t, ListIterator<T>const& startIter, ListIterator<T>const& endIter, EqualFunctionType equalMethod)
		{
			if (startIter == endIter)return 0;
			vListElement* p = startIter.get();
			index_t c = 0;
			while (p != endIter.get())
			{
				if (equalMethod(p->Current(), t)) { c++; }
				p = p->next;
				if (p == startIter.get())break;
			}
			return c;
		}

		template<class T>T* List<T>::PickOutPointer(index_t index)
		{
			vListElement* p = GetVListElementPointerByIndex(index);
			if (p == NULL)Throw<PIndexOutOfRangeException>();
			if (p == pLast)pLast = p->head;
			if (p == pFirst)pFirst = p->next;
			if (p->next)p->next->head = p->head;
			if (p->head)p->head->next = p->next;
			Length--;
			T* pt = p->pointer;
			p->pointer = NULL;
			delete p;
			return pt;
		}

		template<class T>void List<T>::Resize(index_t len)
		{
			if (len < 0)Throw<PInvalidArgumentException>();
			if (len == Length)return;
			if (len < Length)return Remove(len);
			while (Length < len)
			{
				vListElement* p = new vListElement();
				if (Length == 0)
				{
					pFirst = pLast = p;
				}
				else
				{
					p->head = pLast;
					pLast->next = p;
					pLast = p;
				}
				++Length;
			}
			if (_isRec) { pFirst->head = pLast; pLast->next = pFirst; }
			else { pFirst->head = pLast->next = NULL; }
		}


		template<typename T>struct PList : ptr<Object>
		{
			typedef List<T> vList;
		public:
			typedef T value_type;
			typedef index_t difference_type;
			typedef T const* pointer;
			typedef T const& reference;
			typedef ListIterator<T> iterator;
			typedef ListIterator<T const> const_iterator;
#ifdef _INITIALIZER_LIST_//初始化列表支持
			PList(std::initializer_list<T> const& lst) :ptr<Object>(new vList(lst)) {}
#endif
			//通用基类方法
			PMETHODS(PList, vList);
			/**
			@brief 获取一个bool值，指示该列表是否循环*/
			bool GetIsRecycle()const { return Check()->GetIsRecycle(); }
			/**
			@brief 设置一个bool值，指示该列表是否循环*/
			void SetIsRecycle(bool is) { Check()->SetIsRecycle(is); }
			/**
			@brief 构造n个默认构造元素的List*/
			PList(index_t n) :ptr<Object>(new vList(n)) {}
			/**
			@brief 构造并使用一个值初始化所有元素
			@param [模板,可选]参数AnyT表示val的原始数据类型
			@param [传入]参数len表示元素个数
			@param [传入]参数val表示初始值
			@param [传入,可选]参数isRecycle指示该链表是否是循环链表，默认是false*/
			template<class AnyT>PList(index_t len, AnyT const& val, bool isRecycle = false) :ptr<Object>(new vList(len, val, isRecycle)) {}
			/**
			@brief 从迭代器构造
			@param [模板,可选]参数VT表示迭代器的容器数据类型
			@param [模板,可选]参数AnyT表示迭代器检索元素类型
			@param [传入]参数begin表示起始迭代器
			@param [传入]参数end表示终止迭代器
			@note 当该迭代器为循环迭代器时，生成的链表将是循环的*/
			template<class IT>PList(IT const&begin, IT const&end,typename UseIf<IsConvertible<typename IT::value_type,T>::V>::T*p=NULL) :ptr<Object>(new vList(begin, end)) {}
			/**
			@brief 提供使用下标进行的随机访问（不推荐此类访问方式）*/
			T& operator[](index_t index) { return (*Check())[index]; }
			/**
			@brief 随机访问*/
			inline T const& operator[](index_t index)const { return (*const_cast<PList<T>*>(this))[index]; }
			/**
			@brief 获取第一个元素的迭代器*/
			inline ListIterator<T> begin() { return Check()->begin(); }
			/**
			@brief 获取第一个元素的迭代器*/
			inline ListIterator<T const> begin()const { return const_cast<PList*>(this)->begin(); }
			/**
			@brief 获取最后一个元素的迭代器*/
			inline ReverseListIterator<T> rbegin() { return Check()->rbegin(); }
			/**
			@brief 获取最后一个元素的迭代器*/
			inline ReverseListIterator<T const> rbegin()const { return const_cast<PList*>(this)->rbegin(); }
			/**
			@brief 获取最后终止位置元素的迭代器*/
			inline ListIterator<T> end() { return Check()->end(); }
			/**
			@brief 获取最后终止位置元素的迭代器*/
			inline ListIterator<T const> end()const { return Check()->end(); }
			/**
			@brief 获取起始前位置元素的迭代器*/
			inline ReverseListIterator<T> rend() { return Check()->rend(); }
			/**
			@brief 获取起始前位置元素的迭代器*/
			inline ReverseListIterator<T const> rend()const { return Check()->rend(); }
			/**
			@brief 获取链表的元素数*/
			index_t GetLength()const { return Check()->Length; }
			/**
			@brief 获取第一个元素的引用*/
			T& FirstElement() { return Check()->FirstElement(); }
			/**
			@brief 获取第一个元素的引用*/
			T const&FirstElement()const { return Check()->FirstElement(); }
			/**
			@brief 获取最后一个元素的引用*/
			T& LastElement() { return Check()->LastElement(); }
			/**
			@brief 获取最后一个元素的引用*/
			T const&LastElement()const { return Check()->LastElement(); }

			/**
			@brief 在该链表的指定区域查找元素与指定值相等的第一个节点所在位置
			@param [模板,可选]参数AnyT表示t的类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex表示区域起始位置
			@param [传入]参数equalMethod提供比较链表节点元素和t相等的方法
			@return 返回匹配节点的位置，如果没有节点的元素与指定值相等，则返回-1*/
			template<class AnyT, class EqualFunctionType> index_t IndexOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod)const { return Check()->IndexOf<AnyT, EqualFunctionType>(t, startIndex, equalMethod); }
			/**
			@brief 在该链表的指定区域查找元素与指定值相等的第一个节点所在位置
			@param [模板,可选]参数AnyT表示t的类型
			@param [传入]参数t表示指定值
			@param [传入,可选]参数startIndex表示区域起始位置，默认是0
			@return 返回匹配节点的位置，如果没有节点的元素与指定值相等，则返回-1*/
			template<class AnyT> index_t IndexOf(AnyT t, index_t startIndex = 0)const { return Check()->IndexOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该链表的指定区域查找元素与指定值相等的第一个节点所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的节点数
			@param [传入]参数equalMethod提供比较节点元素和t相等的方法
			@return 返回匹配节点的位置，如果没有节点元素与指定值相等，则返回-1*/
			template<class AnyT, class EqualFunctionType> index_t IndexOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod)const { return Check()->IndexOf<AnyT, EqualFunctionType>(t, startIndex, length, equalMethod); }
			/**
			@brief 在该链表的指定区域查找元素与指定值相等的第一个节点所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的节点数
			@return 返回匹配节点的位置，如果没有节点元素与指定值相等，则返回-1*/
			template<class AnyT> index_t IndexOf(AnyT t, index_t startIndex, index_t length)const { return Check()->IndexOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该链表的指定区域查找元素与指定值相等的最后一个节点所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex表示区域起始位置
			@param [传入]参数equalMethod提供比较节点元素和t相等的方法
			@return 返回匹配节点的位置，如果没有节点元素与指定值相等，则返回-1*/
			template<class AnyT, class EqualFunctionType> index_t LastIndexOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod)const { return Check()->LastIndexOf<AnyT, EqualFunctionType>(t, startIndex, equalMethod); }
			/**
			@brief 在该链表的指定区域查找元素与指定值相等的最后一个节点所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入,可选]参数startIndex表示区域起始位置，默认是0
			@return 返回匹配节点的位置，如果没有节点元素与指定值相等，则返回-1*/
			template<class AnyT> index_t LastIndexOf(AnyT t, index_t startIndex = 0)const { return Check()->LastIndexOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 在该链表的指定区域查找元素与指定值相等的最后一个节点所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的元素数
			@param [传入]参数equalMethod提供比较链表节点元素和t相等的方法
			@return 返回匹配节点的位置，如果没有节点元素与指定值相等，则返回-1*/
			template<class AnyT, class EqualFunctionType> index_t LastIndexOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod)const { return Check()->LastIndexOf<AnyT, EqualFunctionType>(t, startIndex, length, equalMethod); }
			/**
			@brief 在该链表的指定区域查找元素与指定值相等的最后一个节点所在位置
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex指示区域起始位置
			@param [传入]参数length表示区域的元素数
			@return 返回匹配节点的位置，如果没有节点元素与指定值相等，则返回-1*/
			template<class AnyT> index_t LastIndexOf(AnyT t, index_t startIndex, index_t length)const { return Check()->LastIndexOf<AnyT, typename  EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 反转链表所有元素*/
			void Reverse() { return Check()->Reverse(); }
			/**
			@brief 在链表的结尾附加元素
			@param [模板,可选]参数AnyT表示t的数据类型
			@param [传入]参数t表示附加的元素
			@note 该操作将使节点数+1*/
			template<class AnyT> void Append(AnyT const & t) { Check()->Append(t); }
			/**
			@brief 在链表的结尾位置附加数组
			@param [模板,可选]参数AnyT表示xArray的元素数据类型
			@param [传入]参数xArray表示附加的数组
			@note 该操作将使元素数+xArray数组元素数*/
			template<class AnyT>void AppendArray(ptr<IArray<AnyT>> const & t) { Check()->AppendArray(*t.Check()); }
			/**
			@brief 在链表的结尾位置附加链表
			@param [模板,可选]参数AnyT表示t的元素数据类型
			@param [传入]参数t表示附加的链表
			@note 该操作将使元素数+t链表元素数*/
			template<class AnyT>void AppendList(PList<AnyT> const & t) { Check()->AppendList(*t.Check()); }

			/**
			@brief 在链表的指定位置插入元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数index表示插入位置
			@param [传入]参数t表示要插入的元素*/
			template<class AnyT> void Insert(index_t index, AnyT const & t) { Check()->Insert(index, t); }
			/**
			@brief 在链表的指定位置插入元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数iter表示插入位置（正向迭代器）
			@param [传入]参数t表示要插入的元素
			@return 返回新插入元素的迭代器*/
			template<class AnyT>ListIterator<T> Insert(const ListIterator<T>&iter, AnyT const & t) { return Check()->Insert(iter, t); }
			/**
			@brief 在链表的指定位置插入数组
			@param [模板,可选]参数AnyT表示xArray的元素数据类型
			@param [传入]参数index表示插入位置
			@param [传入]参数xArray表示要插入的数组*/
			template<class AnyT> void InsertArray(index_t index, ptr<IArray<AnyT>> const &xArray) { return Check()->InsertArray(index, *xArray.Check()); }
			/**
			@brief 在链表的指定位置插入数组
			@param [模板,可选]参数AnyT表示xArray的元素数据类型
			@param [传入]参数iter表示插入位置（正向迭代器）
			@param [传入]参数xArray表示要插入的数组
			@return 返回插入数组元素第一个元素的迭代器*/
			template<class AnyT> ListIterator<T> InsertArray(const ListIterator<T>&iter, ptr<IArray<AnyT>> const &xArray) { return Check()->InsertArray(iter, *xArray.Check()); }
			/**
			@brief 在该链表的指定位置插入链表
			@param [模板,可选]参数AnyT表示xArray的元素数据类型
			@param [传入]参数index表示插入位置
			@param [传入]参数t表示要插入的链表*/
			template<class AnyT>void InsertList(index_t index, PList<AnyT> const & t) { return Check()->InsertList(index, *t.Check()); }
			/**
			@brief 在链表的指定位置插入链表
			@param [模板,可选]参数AnyT表示list的元素数据类型
			@param [传入]参数iter表示插入位置（迭代器）
			@param [传入]参数t表示要插入的链表
			@return 返回插入链表位置的新迭代器*/
			template<class AnyT>ListIterator<T> InsertList(const ListIterator<T>&iter, PList<AnyT> const & list) { return Check()->InsertList(iter, *list.Check()); }
			/**
			@brief 将链表中所有元素的值设置为t
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示设置目标值*/
			template<class AnyT> void ResetTo(AnyT const & t) { Check()->ResetTo(t); }
			/**
			@brief 将链表中指定区域的元素的值设置为t
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示设置目标值
			@param [传入]参数startIndex表示设置起始位置
			@param [传入]参数length表示设置元素数量*/
			template<class AnyT> void ResetTo(AnyT const & t, index_t index, index_t length) { Check()->ResetTo(t, index, length); }

			/**
			@brief 移除指定位置的元素
			@param [传入]参数startIndex表示指定的位置
			@note 该操作将使Length-1*/
			void Remove(index_t startIndex) { Check()->Remove(startIndex); }
			/**
			@brief 移除指定区域的元素
			@param [传入]参数startIndex表示指定的起始移除位置
			@param [传入]参数length表示需要移除的元素数量
			@note 被移除部分元素将立即被析构*/
			void Remove(index_t startIndex, index_t length) { Check()->Remove(startIndex, length); }
			/**
			@brief 移除指定区域的元素
			@param [传入]参数startIter表示指定的起始移除位置
			@param [传入]参数endIter表示终结位置
			@return 返回替换起始位置元素的新迭代器*/
			ListIterator<T> Remove(const ListIterator<T>& startIter, const ListIterator<T>& endIter) { return Check()->Remove(startIter, endIter); }

			/**
			@brief 移除指定位置的元素
			@param [传入]参数index表示指定的位置*/
			void RemoveAt(index_t index) { Check()->RemoveAt(index); }
			/**
			@brief 移除指定位置的元素
			@param [传入]参数iter表示指定的位置
			@return 返回替换移除位置元素的新迭代器*/
			ListIterator< T> RemoveAt(const ListIterator<T>& iter) { return Check()->RemoveAt(iter); }

			/**
			@brief 移除链表指定区域中首个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位
			@param [传入]参数equalMethod提供比较链表元素和t相等的方法
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t RemoveFirstOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod) { return Check()->RemoveFirstOf<AnyT, EqualFunctionType>(t, startIndex, equalMethod); }
			/**
			@brief 移除链表指定区域中首个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t为指定的要移除的值
			@param [传入,可选]参数startIndex指示开始进行比较的位置，默认是0
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT>index_t RemoveFirstOf(AnyT t, index_t startIndex = 0) { return Check()->RemoveFirstOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 移除链表指定区域中首个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数length指示比较的元素数
			@param [传入]参数equalMethod提供比较链表元素和t相等的方法
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t RemoveFirstOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod) { return Check()->RemoveFirstOf<AnyT, EqualFunctionType>(t, startIndex, length, equalMethod); }
			/**
			@brief 移除链表指定区域中首个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数length指示比较的元素数
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT>index_t RemoveFirstOf(AnyT t, index_t startIndex, index_t length) { return Check()->RemoveFirstOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 移除链表指定区域中首个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIter指示开始进行比较的位置
			@param [传入]参数endIter指示比较的终结位置
			@param [传入]参数equalMethod提供比较链表元素和t相等的方法
			@return 返回替换移除的元素所在位置的迭代器。如果未移除任何元素，则返回end()*/
			template<class AnyT, class EqualFunctionType>ListIterator<T> RemoveFirstOf(AnyT t, const ListIterator< T>& startIter, const ListIterator<T>& endIter, EqualFunctionType equalMethod) { return Check()->RemoveFirstOf<AnyT, EqualFunctionType>(t, startIter, endIter, equalMethod); }
			/**
			@brief 移除链表指定区域中首个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIter指示开始进行比较的位置
			@param [传入]参数endIter指示比较的终结位置
			@return 返回替换移除的元素所在位置的迭代器。如果未移除任何元素，则返回end()*/
			template<class AnyT>ListIterator<T> RemoveFirstOf(AnyT t, const ListIterator<T>& startIter, const ListIterator< T>& endIter) { return Check()->RemoveFirstOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIter, endIter, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 移除链表指定区域中最后一个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数equalMethod提供比较链表元素和t相等的方法
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t RemoveLastOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod) { return Check()->RemoveLastOf<AnyT, EqualFunctionType>(t, startIndex, equalMethod); }
			/**
			@brief 移除链表指定区域中最后一个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t为指定的要移除的值
			@param [传入,可选]参数startIndex指示开始进行比较的位置，默认是0
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT>index_t RemoveLastOf(AnyT t, index_t startIndex = 0) { return Check()->RemoveLastOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 移除链表指定区域中最后一个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数length指示比较的元素数
			@param [传入]参数equalMethod提供比较链表元素和t相等的方法
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT, class EqualFunctionType>index_t RemoveLastOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod) { return Check()->RemoveLastOf<AnyT, EqualFunctionType>(t, startIndex, length, equalMethod); }
			/**
			@brief 移除链表指定区域中最后一个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIndex指示开始进行比较的位置
			@param [传入]参数length指示比较的元素数
			@return 返回移除的元素所在位置.如果未移除任何元素，则返回-1*/
			template<class AnyT>index_t RemoveLastOf(AnyT t, index_t startIndex, index_t length) { return Check()->RemoveLastOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 移除链表指定区域中最后一个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIter指示开始进行比较的位置
			@param [传入]参数endIter指示比较的终结位置
			@param [传入]参数equalMethod提供比较链表元素和t相等的方法
			@return 返回替换移除的元素所在位置的迭代器。如果未移除任何元素，则返回end()*/
			template<class AnyT, class EqualFunctionType>ListIterator<T> RemoveLastOf(AnyT t, const ListIterator<T>& startIter, const ListIterator<T>& endIter, EqualFunctionType equalMethod) { return Check()->RemoveLastOf<AnyT, EqualFunctionType>(t, startIter, endIter, equalMethod); }
			/**
			@brief 移除链表指定区域中最后一个与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t为指定的要移除的值
			@param [传入]参数startIter指示开始进行比较的位置
			@param [传入]参数endIter指示比较的终结位置
			@return 返回替换移除的元素所在位置的迭代器。如果未移除任何元素，则返回end()*/
			template<class AnyT>ListIterator<T> RemoveLastOf(AnyT t, const ListIterator<T>& startIter, const ListIterator<T>& endIter) { return Check()->RemoveLastOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIter, endIter, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 移除指定区域内所有与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入,可选]参数startIndex表示区域的起始位置
			@param [传入]参数equalMethod提供比较t和链表元素相等的方法
			@return 返回实际移除的元素数*/
			template<class AnyT, class EqualFunctionType>index_t RemoveAllOf(AnyT t, index_t startIndex, EqualFunctionType equalMethod) { return Check()->RemoveAllOf<AnyT, EqualFunctionType>(t, startIndex, equalMethod); }
			/**
			@brief 移除指定区域内所有与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的类型
			@param [传入]参数t表示指定值
			@param [传入,可选]参数startIndex表示区域的起始位置，默认是0
			@return 返回实际移除的元素数*/
			template<class AnyT>index_t RemoveAllOf(AnyT t, index_t startIndex = 0) { return Check()->RemoveAllOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 移除指定区域内所有与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex表示区域的起始位置
			@param [传入]参数length表示区域的元素数
			@param [传入]参数equalMethod提供比较t和链表元素相等的方法
			@return 返回实际移除的元素数*/
			template<class AnyT, class EqualFunctionType>index_t RemoveAllOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod) { return Check()->RemoveAllOf<AnyT, EqualFunctionType>(t, startIndex, length, equalMethod); }
			/**
			@brief 移除指定区域内所有与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIndex表示区域的起始位置
			@param [传入]参数length表示区域的元素数
			@return 返回实际移除的元素数*/
			template<class AnyT>index_t RemoveAllOf(AnyT t, index_t startIndex, index_t length) { return Check()->RemoveAllOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 移除指定区域内所有与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIter表示区域的起始位置
			@param [传入]参数endIter表示区域的终结位置
			@param [传入]参数equalMethod提供比较t和链表元素相等的方法
			@return 返回实际移除的元素数*/
			template<class AnyT, class EqualFunctionType>index_t RemoveAllOf(AnyT t, ListIterator< T>const& startIter, ListIterator<T>const& endIter, EqualFunctionType equalMethod) { return Check()->RemoveAllOf<AnyT, EqualFunctionType>(t, startIter, endIter, equalMethod); }
			/**
			@brief 移除指定区域内所有与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的类型
			@param [传入]参数t表示指定值
			@param [传入]参数startIter表示区域的起始位置
			@param [传入]参数endIter表示区域的终结位置
			@return 返回实际移除的元素数*/
			template<class AnyT>index_t RemoveAllOf(AnyT t, ListIterator<T>const& startIter, ListIterator<T>const& endIter) { return Check()->RemoveAllOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIter, endIter, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 移除指定区域内的一些与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定的值
			@param [传入]参数startIndex表示区域的起始位置
			@param [传入]参数length表示区域内的元素数
			@param [传入]参数maxCount表示最多移除的元素数
			@param [传入]参数equalMethod提供比较t和元素相等的方法
			@return 返回实际移除的元素数*/
			template<class AnyT, class EqualFunctionType>index_t RemoveSomeOf(AnyT t, index_t startIndex, index_t length, index_t maxCount, EqualFunctionType equalMethod) { return Check()->RemoveSomeOf<AnyT, EqualFunctionType>(t, startIndex, length, maxCount, equalMethod); }
			/**
			@brief 移除指定区域内的一些与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定的值
			@param [传入]参数startIndex表示区域的起始位置
			@param [传入]参数length表示区域内的元素数
			@param [传入]参数maxCount表示最多移除的元素数
			@return 返回实际移除的元素数*/
			template<class AnyT>index_t RemoveSomeOf(AnyT t, index_t startIndex, index_t length, index_t maxCount) { return Check()->RemoveSomeOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, maxCount, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 移除指定区域内的一些与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定的值
			@param [传入]参数startIter表示区域的起始位置
			@param [传入]参数endIter表示区域终结位置
			@param [传入]参数maxCount表示最多移除的元素数
			@param [传入]参数equalMethod提供比较t和元素相等的方法
			@return 返回实际移除的元素数*/
			template<class AnyT, class EqualFunctionType>index_t RemoveSomeOf(AnyT t, ListIterator<T>const& startIter, ListIterator<T>const& endIter, index_t maxCount, EqualFunctionType equalMethod) { return Check()->RemoveSomeOf<AnyT, EqualFunctionType>(t, startIter, endIter, maxCount, equalMethod); }
			/**
			@brief 移除指定区域内的一些与指定值相等的元素
			@param [模板,可选]参数AnyT表示t的原始数据类型
			@param [传入]参数t表示指定的值
			@param [传入]参数startIter表示区域的起始位置
			@param [传入]参数endIter表示区域终结位置
			@param [传入]参数maxCount表示最多移除的元素数
			@return 返回实际移除的元素数*/
			template<class AnyT>index_t RemoveSomeOf(AnyT t, ListIterator<T>const& startIter, ListIterator<T>const& endIter, index_t maxCount) { return Check()->RemoveSomeOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIter, endIter, maxCount, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将指定位置的元素替换为一个指定的值
			@param [模板,可选]To表示参数to的原始数据类型
			@param [传入]参数index表示指定的位置
			@param [传入]参数to表示指定的替换后的值
			@note 与直接赋值方法不同，该方法使用重构方法来实现值替换*/
			template<class To>void RemoveAndReplaceAt(index_t index, To to) { return Check()->RemoveAndReplaceAt<To>(index, to); }
			/**
			@brief 将指定位置的元素替换为一个指定的值
			@param [模板,可选]To表示参数to的原始数据类型
			@param [传入]参数iter表示指定的位置（正向迭代器）
			@param [传入]参数to表示指定的替换后的值
			@note 与直接赋值方法不同，该方法使用重构方法来实现值替换*/
			template<class To>void RemoveAndReplaceAt(ListIterator<T>const&iter, To to) { return Check()->RemoveAndReplaceAt<To>(iter, to); }
			/**
			@brief 将指定区域内第一个与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入,可选]参数startIndex表示指定区域的起始位置
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回移除元素所在位置，若未移除任何元素返回-1*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceFirstOf(AnyT t, To to, index_t startIndex, EqualFunctionType equalMethod) { return Check()->ReplaceFirstOf<AnyT, EqualFunctionType>(t, to, startIndex, equalMethod); }
			/**
			@brief 将指定区域内第一个与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入,可选]参数startIndex表示指定区域的起始位置，默认是0
			@return 返回移除元素所在位置，若未移除任何元素返回-1*/
			template<class AnyT, class To>index_t ReplaceFirstOf(AnyT t, To to, index_t startIndex = 0) { return Check()->ReplaceFirstOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将指定区域内第一个与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIndex表示指定区域的起始位置
			@param [传入]参数length表示指定区域的元素数
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回移除元素所在位置，若未移除任何元素返回-1*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceFirstOf(AnyT t, To to, index_t startIndex, index_t length, EqualFunctionType equalMethod) { return Check()->ReplaceFirstOf<AnyT, EqualFunctionType>(t, to, startIndex, length, equalMethod); }
			/**
			@brief 将指定区域内第一个与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIndex表示指定区域的起始位置
			@param [传入]参数length表示指定区域的元素数
			@return 返回移除元素所在位置，若未移除任何元素返回-1*/
			template<class AnyT, class To>index_t ReplaceFirstOf(AnyT t, To to, index_t startIndex, index_t length) { return Check()->ReplaceFirstOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将指定区域内第一个与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIter表示指定区域的起始位置（正向迭代器）
			@param [传入]参数endIter表示指定区域的终结位置（反向迭代器）
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回替换移除元素位置的新迭代器，若未移除任何元素返回end()*/
			template<class AnyT, class EqualFunctionType, class To>ListIterator<T> ReplaceFirstOf(AnyT t, To to, ListIterator<T>const& startIter, ListIterator<T>const& endIter, EqualFunctionType equalMethod) { return Check()->ReplaceFirstOf<AnyT, EqualFunctionType>(t, to, startIter, endIter, equalMethod); }
			/**
			@brief 将指定区域内第一个与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIter表示指定区域的起始位置（正向迭代器）
			@param [传入]参数endIter表示指定区域的终结位置（反向迭代器）
			@return 返回替换移除元素位置的新迭代器，若未移除任何元素返回end()*/
			template<class AnyT, class To>ListIterator<T> ReplaceFirstOf(AnyT t, To to, ListIterator<T>const& startIter, ListIterator<T>const& endIter) { return Check()->ReplaceFirstOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIter, endIter, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将指定区域内最后一个与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入,可选]参数startIndex表示指定区域的起始位置
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回移除元素所在位置，若未移除任何元素返回-1*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceLastOf(AnyT t, To to, index_t startIndex, EqualFunctionType equalMethod) { return Check()->ReplaceLastOf<AnyT, EqualFunctionType>(t, to, startIndex, equalMethod); }
			/**
			@brief 将指定区域内最后一个与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入,可选]参数startIndex表示指定区域的起始位置，默认是0
			@return 返回移除元素所在位置，若未移除任何元素返回-1*/
			template<class AnyT, class To>index_t ReplaceLastOf(AnyT t, To to, index_t startIndex = 0) { return Check()->ReplaceLastOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将指定区域内最后一个与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIndex表示指定区域的起始位置
			@param [传入]参数length表示指定区域的元素数
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回移除元素所在位置，若未移除任何元素返回-1*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceLastOf(AnyT t, To to, index_t startIndex, index_t length, EqualFunctionType equalMethod) { return Check()->ReplaceLastOf<AnyT, EqualFunctionType>(t, to, startIndex, length, equalMethod); }
			/**
			@brief 将指定区域内最后一个与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIndex表示指定区域的起始位置
			@param [传入]参数length表示指定区域的元素数
			@return 返回移除元素所在位置，若未移除任何元素返回-1*/
			template<class AnyT, class To>index_t ReplaceLastOf(AnyT t, To to, index_t startIndex, index_t length) { return Check()->ReplaceLastOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将指定区域内最后一个与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIter表示指定区域的起始位置（正向迭代器）
			@param [传入]参数endIter表示指定区域的终结位置（反向迭代器）
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回替换移除元素位置的新迭代器，若未移除任何元素返回end()*/
			template<class AnyT, class EqualFunctionType, class To>ListIterator<T> ReplaceLastOf(AnyT t, To to, ListIterator<T>const& startIter, ListIterator<T>const& endIter, EqualFunctionType equalMethod) { return Check()->ReplaceLastOf<AnyT, EqualFunctionType>(t, to, startIter, endIter, equalMethod); }
			/**
			@brief 将指定区域内最后一个与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIter表示指定区域的起始位置（正向迭代器）
			@param [传入]参数endIter表示指定区域的终结位置（反向迭代器）
			@return 返回替换移除元素位置的新迭代器，若未移除任何元素返回end()*/
			template<class AnyT, class To>ListIterator< T> ReplaceLastOf(AnyT t, To to, ListIterator< T>const& startIter, ListIterator< T>const& endIter) { return Check()->ReplaceLastOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIter, endIter, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将指定区域内所有与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入,可选]参数startIndex表示指定区域的起始位置
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回实际移除元素数量*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceAllOf(AnyT t, To to, index_t startIndex, EqualFunctionType equalMethod) { return Check()->ReplaceAllOf<AnyT, EqualFunctionType>(t, to, startIndex, equalMethod); }
			/**
			@brief 将指定区域内所有与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入,可选]参数startIndex表示指定区域的起始位置，默认是0
			@return 返回实际移除元素数量*/
			template<class AnyT, class To>index_t ReplaceAllOf(AnyT t, To to, index_t startIndex = 0) { return Check()->ReplaceAllOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIndex, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将指定区域内所有与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIndex表示指定区域的起始位置
			@param [传入]参数length表示指定区域的元素数
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回实际移除元素数量*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceAllOf(AnyT t, To to, index_t startIndex, index_t length, EqualFunctionType equalMethod) { return Check()->ReplaceAllOf<AnyT, EqualFunctionType>(t, to, startIndex, length, equalMethod); }
			/**
			@brief 将指定区域内所有与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIndex表示指定区域的起始位置
			@param [传入]参数length表示指定区域的元素数
			@return 返回实际移除元素数量*/
			template<class AnyT, class To>index_t ReplaceAllOf(AnyT t, To to, index_t startIndex, index_t length) { return Check()->ReplaceAllOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将指定区域内所有与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIter表示指定区域的起始位置（正向迭代器）
			@param [传入]参数endIter表示指定区域的终结位置（反向迭代器）
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回实际移除元素数量*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceAllOf(AnyT t, To to, ListIterator<T>const& startIter, ListIterator<T>const& endIter, EqualFunctionType equalMethod) { return Check()->ReplaceAllOf<AnyT, EqualFunctionType>(t, to, startIter, endIter, equalMethod); }
			/**
			@brief 将指定区域内所有与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIter表示指定区域的起始位置（正向迭代器）
			@param [传入]参数endIter表示指定区域的终结位置（反向迭代器）
			@return 返回实际移除元素数量*/
			template<class AnyT, class To>index_t ReplaceAllOf(AnyT t, To to, ListIterator<T>const& startIter, ListIterator<T>const& endIter) { return Check()->ReplaceAllOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIter, endIter, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将指定区域内一部分与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIndex表示指定区域的起始位置
			@param [传入]参数length表示指定区域的元素数
			@param [传入]参数maxCount表示最多移除的元素数
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回实际移除元素数量*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceSomeOf(AnyT t, To to, index_t startIndex, index_t length, index_t maxCount, EqualFunctionType equalMethod) { return Check()->ReplaceSomeOf<AnyT, EqualFunctionType>(t, to, startIndex, length, maxCount, equalMethod); }
			/**
			@brief 将指定区域内一部分与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIndex表示指定区域的起始位置
			@param [传入]参数length表示指定区域的元素数
			@param [传入]参数maxCount表示最多移除的元素数
			@return 返回实际移除元素数量*/
			template<class AnyT, class To>index_t ReplaceSomeOf(AnyT t, To to, index_t startIndex, index_t length, index_t maxCount) { return Check()->ReplaceSomeOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIndex, length, maxCount, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 将指定区域内一部分与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIter表示指定区域的起始位置（正向迭代器）
			@param [传入]参数endIter表示指定区域的终结位置（反向迭代器）
			@param [传入]参数maxCount表示最多移除的元素数
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回实际移除元素数量*/
			template<class AnyT, class EqualFunctionType, class To>index_t ReplaceSomeOf(AnyT t, To to, ListIterator<T>const& startIter, ListIterator<T>const& endIter, index_t maxCount, EqualFunctionType equalMethod) { return Check()->ReplaceSomeOf<AnyT, EqualFunctionType>(t, to, startIter, endIter, maxCount, equalMethod); }
			/**
			@brief 将指定区域内一部分与指定值相等的元素替换为另一个指定的值
			@param [模板,可选]AnyT表示指定值t的原始数据类型
			@param [模板,可选]To表示指定值to的原始数据类型
			@param [传入]参数t表示指定的用以比较的值
			@param [传入]参数to表示指定的替换后的值
			@param [传入]参数startIter表示指定区域的起始位置（正向迭代器）
			@param [传入]参数endIter表示指定区域的终结位置（反向迭代器）
			@param [传入]参数maxCount表示最多移除的元素数
			@return 返回实际移除元素数量*/
			template<class AnyT, class To>index_t ReplaceSomeOf(AnyT t, To to, ListIterator<T>const& startIter, ListIterator<T>const& endIter, index_t maxCount) { return Check()->ReplaceSomeOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, to, startIter, endIter, maxCount, EqualMethodObject<T&, AnyT>::Method); }

			/**
			@brief 统计与指定值相等的元素数量
			@param [模板]AnyT表示参数t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定的值
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回与指定值相等的元素数量*/
			template<class AnyT, class EqualFunctionType>index_t CountOf(AnyT t, EqualFunctionType equalMethod) { return Check()->CountOf<AnyT, EqualFunctionType>(t, equalMethod); }
			/**
			@brief 统计与指定值相等的元素数量
			@param [模板]AnyT表示参数t的原始数据类型
			@param [传入]参数t表示指定的值
			@return 返回与指定值相等的元素数量*/
			template<class AnyT>index_t CountOf(AnyT t) { return Check()->CountOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 统计指定区域中与指定值相等的元素数量
			@param [模板]AnyT表示参数t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定的值
			@param [传入]参数startIndex表示指定区域的起始位置
			@param [传入]参数length表示指定区域的元素数
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回与指定值相等的元素数量*/
			template<class AnyT, class EqualFunctionType>index_t CountOf(AnyT t, index_t startIndex, index_t length, EqualFunctionType equalMethod) { return Check()->CountOf<AnyT, EqualFunctionType>(t, startIndex, length, equalMethod); }
			/**
			@brief 统计指定区域中与指定值相等的元素数量
			@param [模板]AnyT表示参数t的原始数据类型
			@param [传入]参数t表示指定的值
			@param [传入]参数startIndex表示指定区域的起始位置
			@param [传入]参数length表示指定区域的元素数
			@return 返回与指定值相等的元素数量*/
			template<class AnyT>index_t CountOf(AnyT t, index_t startIndex, index_t length) { return Check()->CountOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIndex, length, EqualMethodObject<T&, AnyT>::Method); }
			/**
			@brief 统计指定区域中与指定值相等的元素数量
			@param [模板]AnyT表示参数t的原始数据类型
			@param [模板,可选]参数EqualFunctionType表示比较方法类型
			@param [传入]参数t表示指定的值
			@param [传入]参数startIter表示指定区域的起始位置（正向迭代器）
			@param [传入]参数endIter表示指定区域的终结位置（反向迭代器）
			@param [传入]参数equalMethod提供比较t与元素值相等的方法
			@return 返回与指定值相等的元素数量*/
			template<class AnyT, class EqualFunctionType>index_t CountOf(AnyT t, ListIterator<T>const& startIter, ListIterator< T>const& endIter, EqualFunctionType equalMethod) { return Check()->CountOf<AnyT, EqualFunctionType>(t, startIter, endIter, equalMethod); }
			/**
			@brief 统计指定区域中与指定值相等的元素数量
			@param [模板]AnyT表示参数t的原始数据类型
			@param [传入]参数t表示指定的值
			@param [传入]参数startIter表示指定区域的起始位置（正向迭代器）
			@param [传入]参数endIter表示指定区域的终结位置（反向迭代器）
			@return 返回与指定值相等的元素数量*/
			template<class AnyT>index_t CountOf(AnyT t, ListIterator< T>const& startIter, ListIterator<T>const& endIter) { return Check()->CountOf<AnyT, typename EqualMethodObject<T&, AnyT>::T>(t, startIter, endIter, EqualMethodObject<T&, AnyT>::Method); }

			/**
			@brief 将一个对象从集合中取出(取出后集合中将其移除)，并返回其指针
			@param [传入]参数index表示指定的位置
			@return 返回取出对象的指针
			@note 指针不再使用时请自行delete*/
			T* PickOutPointer(index_t index) { return Check()->PickOutPointer(index); }

			/**
			@brief 调整大小
			@param [传入]参数len表示目标大小
			@note 当len比Length大时，新增的元素将使用默认构造；当len比Length小时，链表末尾的Length-len个元素将会被析构*/
			void Resize(index_t len) { return Check()->Resize(len); }
		};
	}
}
#endif
